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


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

(0) CpxRelTRS
(1) SInnermostTerminationProof [BOTH CONCRETE BOUNDS(ID, ID), 188 ms]
(2) CpxRelTRS
(3) RelTrsToTrsProof [UPPER BOUND(ID), 0 ms]
(4) CpxTRS
(5) RenamingProof [BOTH BOUNDS(ID, ID), 0 ms]
(6) CpxRelTRS
(7) RelTrsToWeightedTrsProof [UPPER BOUND(ID), 0 ms]
(8) CpxWeightedTrs
    (9) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
    (10) CpxTypedWeightedTrs
    (11) CompletionProof [UPPER BOUND(ID), 0 ms]
    (12) CpxTypedWeightedCompleteTrs
        (13) NarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (14) CpxTypedWeightedCompleteTrs
        (15) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
        (16) CpxRNTS
        (17) InliningProof [UPPER BOUND(ID), 560 ms]
        (18) CpxRNTS
        (19) SimplificationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (20) CpxRNTS
        (21) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 1 ms]
        (22) CpxRNTS
        (23) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (24) CpxRNTS
        (25) IntTrsBoundProof [UPPER BOUND(ID), 50 ms]
        (26) CpxRNTS
        (27) IntTrsBoundProof [UPPER BOUND(ID), 6 ms]
        (28) CpxRNTS
        (29) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (30) CpxRNTS
        (31) IntTrsBoundProof [UPPER BOUND(ID), 298 ms]
        (32) CpxRNTS
        (33) IntTrsBoundProof [UPPER BOUND(ID), 47 ms]
        (34) CpxRNTS
        (35) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (36) CpxRNTS
        (37) IntTrsBoundProof [UPPER BOUND(ID), 379 ms]
        (38) CpxRNTS
        (39) IntTrsBoundProof [UPPER BOUND(ID), 47 ms]
        (40) CpxRNTS
        (41) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (42) CpxRNTS
        (43) IntTrsBoundProof [UPPER BOUND(ID), 1185 ms]
        (44) CpxRNTS
        (45) IntTrsBoundProof [UPPER BOUND(ID), 479 ms]
        (46) CpxRNTS
        (47) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (48) CpxRNTS
        (49) IntTrsBoundProof [UPPER BOUND(ID), 3044 ms]
        (50) CpxRNTS
        (51) IntTrsBoundProof [UPPER BOUND(ID), 973 ms]
        (52) CpxRNTS
    (53) CompletionProof [UPPER BOUND(ID), 0 ms]
    (54) CpxTypedWeightedCompleteTrs
        (55) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
        (56) CpxRNTS
(57) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms]
(58) CdtProblem
    (59) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms]
    (60) CdtProblem
    (61) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (62) CdtProblem
    (63) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms]
    (64) CdtProblem
    (65) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 137 ms]
    (66) CdtProblem
    (67) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 40 ms]
    (68) CdtProblem
    (69) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (70) CdtProblem
    (71) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (72) CdtProblem
    (73) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (74) CdtProblem
    (75) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (76) CdtProblem
    (77) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (78) CdtProblem
    (79) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms]
    (80) CdtProblem
    (81) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (82) CdtProblem
    (83) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (84) CdtProblem
    (85) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (86) CdtProblem
    (87) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (88) CdtProblem
    (89) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (90) CdtProblem
    (91) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (92) CdtProblem
    (93) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (94) CdtProblem
    (95) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (96) CdtProblem
    (97) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (98) CdtProblem
    (99) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (100) CdtProblem
    (101) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (102) CdtProblem
    (103) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (104) CdtProblem
    (105) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (106) CdtProblem
    (107) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (108) CdtProblem
    (109) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms]
    (110) CdtProblem
    (111) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (112) CdtProblem
    (113) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (114) CdtProblem
    (115) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (116) CdtProblem
    (117) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (118) CdtProblem
    (119) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (120) CdtProblem
    (121) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (122) CdtProblem
    (123) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (124) CdtProblem
    (125) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 25 ms]
    (126) CdtProblem
    (127) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (128) CdtProblem
    (129) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (130) CdtProblem
    (131) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (132) CdtProblem
    (133) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (134) CdtProblem
    (135) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (136) CdtProblem
    (137) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (138) CdtProblem
    (139) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 16 ms]
    (140) CdtProblem
    (141) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (142) CdtProblem
    (143) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (144) CdtProblem
    (145) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (146) CdtProblem
    (147) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms]
    (148) CdtProblem
    (149) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (150) CdtProblem
    (151) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
    (152) CdtProblem
    (153) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (154) CdtProblem
    (155) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
    (156) CdtProblem
    (157) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (158) CdtProblem
    (159) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
    (160) CdtProblem
    (161) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (162) CdtProblem
    (163) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
    (164) CdtProblem
    (165) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (166) CdtProblem
    (167) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
    (168) CdtProblem
    (169) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (170) CdtProblem
    (171) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
    (172) CdtProblem
    (173) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (174) CdtProblem
    (175) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
    (176) CdtProblem
    (177) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (178) CdtProblem
    (179) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
    (180) CdtProblem
    (181) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms]
    (182) CdtProblem
    (183) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (184) CdtProblem
    (185) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (186) CdtProblem
    (187) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (188) CdtProblem
    (189) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (190) CdtProblem
    (191) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 0 ms]
    (192) CdtProblem
    (193) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (194) CdtProblem
    (195) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (196) CdtProblem
    (197) CdtInstantiationProof [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
    (205) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (206) CdtProblem
    (207) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (208) CdtProblem
    (209) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (210) CdtProblem
    (211) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 1 ms]
    (212) CdtProblem
    (213) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (214) CdtProblem
    (215) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (216) CdtProblem
    (217) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (218) CdtProblem
    (219) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (220) CdtProblem
    (221) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (222) CdtProblem
    (223) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (224) CdtProblem
    (225) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 40 ms]
    (226) CdtProblem
    (227) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 57 ms]
    (228) CdtProblem
    (229) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 99 ms]
    (230) CdtProblem
    (231) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 279 ms]
    (232) CdtProblem


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

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


The TRS R consists of the following rules:

   lt0(Cons(x', xs'), Cons(x, xs)) -> lt0(xs', xs)
   g(x, Nil) -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil))))))))))))))))))))))))))))))))))))))))))
   f(x, Nil) -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil))))))))))))))))))))))))))))))))))))))))))
   lt0(x, Nil) -> False
   g(x, Cons(x', xs)) -> g[Ite][False][Ite](lt0(x, Cons(Nil, Nil)), x, Cons(x', xs))
   f(x, Cons(x', xs)) -> f(f[Ite][False][Ite](lt0(x, Cons(Nil, Nil)), x, Cons(x', xs)), f[Ite][False][Ite](lt0(x, Cons(Nil, Nil)), x, Cons(x', xs)))
   number42 -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil))))))))))))))))))))))))))))))))))))))))))
   goal(x, y) -> Cons(f(x, y), Cons(g(x, y), Nil))

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

   g[Ite][False][Ite](False, Cons(x, xs), y) -> g(xs, Cons(Cons(Nil, Nil), y))
   g[Ite][False][Ite](True, x', Cons(x, xs)) -> g(x', xs)
   f[Ite][False][Ite](False, Cons(x, xs), y) -> xs
   f[Ite][False][Ite](True, x', Cons(x, xs)) -> xs
   f[Ite][False][Ite](False, x, y) -> Cons(Cons(Nil, Nil), y)
   f[Ite][False][Ite](True, x, y) -> x

Rewrite Strategy: PARALLEL_INNERMOST
----------------------------------------

(1) SInnermostTerminationProof (BOTH CONCRETE BOUNDS(ID, ID))
proved innermost termination of relative rules
----------------------------------------

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


The TRS R consists of the following rules:

   lt0(Cons(x', xs'), Cons(x, xs)) -> lt0(xs', xs)
   g(x, Nil) -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil))))))))))))))))))))))))))))))))))))))))))
   f(x, Nil) -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil))))))))))))))))))))))))))))))))))))))))))
   lt0(x, Nil) -> False
   g(x, Cons(x', xs)) -> g[Ite][False][Ite](lt0(x, Cons(Nil, Nil)), x, Cons(x', xs))
   f(x, Cons(x', xs)) -> f(f[Ite][False][Ite](lt0(x, Cons(Nil, Nil)), x, Cons(x', xs)), f[Ite][False][Ite](lt0(x, Cons(Nil, Nil)), x, Cons(x', xs)))
   number42 -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil))))))))))))))))))))))))))))))))))))))))))
   goal(x, y) -> Cons(f(x, y), Cons(g(x, y), Nil))

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

   g[Ite][False][Ite](False, Cons(x, xs), y) -> g(xs, Cons(Cons(Nil, Nil), y))
   g[Ite][False][Ite](True, x', Cons(x, xs)) -> g(x', xs)
   f[Ite][False][Ite](False, Cons(x, xs), y) -> xs
   f[Ite][False][Ite](True, x', Cons(x, xs)) -> xs
   f[Ite][False][Ite](False, x, y) -> Cons(Cons(Nil, Nil), y)
   f[Ite][False][Ite](True, x, y) -> x

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:

   lt0(Cons(x', xs'), Cons(x, xs)) -> lt0(xs', xs)
   g(x, Nil) -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil))))))))))))))))))))))))))))))))))))))))))
   f(x, Nil) -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil))))))))))))))))))))))))))))))))))))))))))
   lt0(x, Nil) -> False
   g(x, Cons(x', xs)) -> g[Ite][False][Ite](lt0(x, Cons(Nil, Nil)), x, Cons(x', xs))
   f(x, Cons(x', xs)) -> f(f[Ite][False][Ite](lt0(x, Cons(Nil, Nil)), x, Cons(x', xs)), f[Ite][False][Ite](lt0(x, Cons(Nil, Nil)), x, Cons(x', xs)))
   number42 -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil))))))))))))))))))))))))))))))))))))))))))
   goal(x, y) -> Cons(f(x, y), Cons(g(x, y), Nil))
   g[Ite][False][Ite](False, Cons(x, xs), y) -> g(xs, Cons(Cons(Nil, Nil), y))
   g[Ite][False][Ite](True, x', Cons(x, xs)) -> g(x', xs)
   f[Ite][False][Ite](False, Cons(x, xs), y) -> xs
   f[Ite][False][Ite](True, x', Cons(x, xs)) -> xs
   f[Ite][False][Ite](False, x, y) -> Cons(Cons(Nil, Nil), y)
   f[Ite][False][Ite](True, x, y) -> x

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

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

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


The TRS R consists of the following rules:

   lt0(Cons(x', xs'), Cons(x, xs)) -> lt0(xs', xs)
   g(x, Nil) -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil))))))))))))))))))))))))))))))))))))))))))
   f(x, Nil) -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil))))))))))))))))))))))))))))))))))))))))))
   lt0(x, Nil) -> False
   g(x, Cons(x', xs)) -> g[Ite][False][Ite](lt0(x, Cons(Nil, Nil)), x, Cons(x', xs))
   f(x, Cons(x', xs)) -> f(f[Ite][False][Ite](lt0(x, Cons(Nil, Nil)), x, Cons(x', xs)), f[Ite][False][Ite](lt0(x, Cons(Nil, Nil)), x, Cons(x', xs)))
   number42 -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil))))))))))))))))))))))))))))))))))))))))))
   goal(x, y) -> Cons(f(x, y), Cons(g(x, y), Nil))

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

   g[Ite][False][Ite](False, Cons(x, xs), y) -> g(xs, Cons(Cons(Nil, Nil), y))
   g[Ite][False][Ite](True, x', Cons(x, xs)) -> g(x', xs)
   f[Ite][False][Ite](False, Cons(x, xs), y) -> xs
   f[Ite][False][Ite](True, x', Cons(x, xs)) -> xs
   f[Ite][False][Ite](False, x, y) -> Cons(Cons(Nil, Nil), y)
   f[Ite][False][Ite](True, x, y) -> x

Rewrite Strategy: PARALLEL_INNERMOST
----------------------------------------

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

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

   lt0(Cons(x', xs'), Cons(x, xs)) -> lt0(xs', xs) [1]
   g(x, Nil) -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil)))))))))))))))))))))))))))))))))))))))))) [1]
   f(x, Nil) -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil)))))))))))))))))))))))))))))))))))))))))) [1]
   lt0(x, Nil) -> False [1]
   g(x, Cons(x', xs)) -> g[Ite][False][Ite](lt0(x, Cons(Nil, Nil)), x, Cons(x', xs)) [1]
   f(x, Cons(x', xs)) -> f(f[Ite][False][Ite](lt0(x, Cons(Nil, Nil)), x, Cons(x', xs)), f[Ite][False][Ite](lt0(x, Cons(Nil, Nil)), x, Cons(x', xs))) [1]
   number42 -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil)))))))))))))))))))))))))))))))))))))))))) [1]
   goal(x, y) -> Cons(f(x, y), Cons(g(x, y), Nil)) [1]
   g[Ite][False][Ite](False, Cons(x, xs), y) -> g(xs, Cons(Cons(Nil, Nil), y)) [0]
   g[Ite][False][Ite](True, x', Cons(x, xs)) -> g(x', xs) [0]
   f[Ite][False][Ite](False, Cons(x, xs), y) -> xs [0]
   f[Ite][False][Ite](True, x', Cons(x, xs)) -> xs [0]
   f[Ite][False][Ite](False, x, y) -> Cons(Cons(Nil, Nil), y) [0]
   f[Ite][False][Ite](True, x, y) -> x [0]

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

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

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

   lt0(Cons(x', xs'), Cons(x, xs)) -> lt0(xs', xs) [1]
   g(x, Nil) -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil)))))))))))))))))))))))))))))))))))))))))) [1]
   f(x, Nil) -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil)))))))))))))))))))))))))))))))))))))))))) [1]
   lt0(x, Nil) -> False [1]
   g(x, Cons(x', xs)) -> g[Ite][False][Ite](lt0(x, Cons(Nil, Nil)), x, Cons(x', xs)) [1]
   f(x, Cons(x', xs)) -> f(f[Ite][False][Ite](lt0(x, Cons(Nil, Nil)), x, Cons(x', xs)), f[Ite][False][Ite](lt0(x, Cons(Nil, Nil)), x, Cons(x', xs))) [1]
   number42 -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil)))))))))))))))))))))))))))))))))))))))))) [1]
   goal(x, y) -> Cons(f(x, y), Cons(g(x, y), Nil)) [1]
   g[Ite][False][Ite](False, Cons(x, xs), y) -> g(xs, Cons(Cons(Nil, Nil), y)) [0]
   g[Ite][False][Ite](True, x', Cons(x, xs)) -> g(x', xs) [0]
   f[Ite][False][Ite](False, Cons(x, xs), y) -> xs [0]
   f[Ite][False][Ite](True, x', Cons(x, xs)) -> xs [0]
   f[Ite][False][Ite](False, x, y) -> Cons(Cons(Nil, Nil), y) [0]
   f[Ite][False][Ite](True, x, y) -> x [0]

The TRS has the following type information:
lt0 :: Cons:Nil -> Cons:Nil -> False:True
Cons :: Cons:Nil -> Cons:Nil -> Cons:Nil
g :: Cons:Nil -> Cons:Nil -> Cons:Nil
Nil :: Cons:Nil
f :: Cons:Nil -> Cons:Nil -> Cons:Nil
False :: False:True
g[Ite][False][Ite] :: False:True -> Cons:Nil -> Cons:Nil -> Cons:Nil
f[Ite][False][Ite] :: False:True -> Cons:Nil -> Cons:Nil -> Cons:Nil
number42 :: Cons:Nil
goal :: Cons:Nil -> Cons:Nil -> Cons:Nil
True :: False:True

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

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

   g_2
   f_2
   number42
   goal_2

(c) The following functions are completely defined:

   lt0_2
   g[Ite][False][Ite]_3
   f[Ite][False][Ite]_3

Due to the following rules being added:

   g[Ite][False][Ite](v0, v1, v2) -> Nil [0]
   f[Ite][False][Ite](v0, v1, v2) -> Nil [0]
   lt0(v0, v1) -> null_lt0 [0]

And the following fresh constants:    null_lt0

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

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

   lt0(Cons(x', xs'), Cons(x, xs)) -> lt0(xs', xs) [1]
   g(x, Nil) -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil)))))))))))))))))))))))))))))))))))))))))) [1]
   f(x, Nil) -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil)))))))))))))))))))))))))))))))))))))))))) [1]
   lt0(x, Nil) -> False [1]
   g(x, Cons(x', xs)) -> g[Ite][False][Ite](lt0(x, Cons(Nil, Nil)), x, Cons(x', xs)) [1]
   f(x, Cons(x', xs)) -> f(f[Ite][False][Ite](lt0(x, Cons(Nil, Nil)), x, Cons(x', xs)), f[Ite][False][Ite](lt0(x, Cons(Nil, Nil)), x, Cons(x', xs))) [1]
   number42 -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil)))))))))))))))))))))))))))))))))))))))))) [1]
   goal(x, y) -> Cons(f(x, y), Cons(g(x, y), Nil)) [1]
   g[Ite][False][Ite](False, Cons(x, xs), y) -> g(xs, Cons(Cons(Nil, Nil), y)) [0]
   g[Ite][False][Ite](True, x', Cons(x, xs)) -> g(x', xs) [0]
   f[Ite][False][Ite](False, Cons(x, xs), y) -> xs [0]
   f[Ite][False][Ite](True, x', Cons(x, xs)) -> xs [0]
   f[Ite][False][Ite](False, x, y) -> Cons(Cons(Nil, Nil), y) [0]
   f[Ite][False][Ite](True, x, y) -> x [0]
   g[Ite][False][Ite](v0, v1, v2) -> Nil [0]
   f[Ite][False][Ite](v0, v1, v2) -> Nil [0]
   lt0(v0, v1) -> null_lt0 [0]

The TRS has the following type information:
lt0 :: Cons:Nil -> Cons:Nil -> False:True:null_lt0
Cons :: Cons:Nil -> Cons:Nil -> Cons:Nil
g :: Cons:Nil -> Cons:Nil -> Cons:Nil
Nil :: Cons:Nil
f :: Cons:Nil -> Cons:Nil -> Cons:Nil
False :: False:True:null_lt0
g[Ite][False][Ite] :: False:True:null_lt0 -> Cons:Nil -> Cons:Nil -> Cons:Nil
f[Ite][False][Ite] :: False:True:null_lt0 -> Cons:Nil -> Cons:Nil -> Cons:Nil
number42 :: Cons:Nil
goal :: Cons:Nil -> Cons:Nil -> Cons:Nil
True :: False:True:null_lt0
null_lt0 :: False:True:null_lt0

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

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

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

   lt0(Cons(x', xs'), Cons(x, xs)) -> lt0(xs', xs) [1]
   g(x, Nil) -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil)))))))))))))))))))))))))))))))))))))))))) [1]
   f(x, Nil) -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil)))))))))))))))))))))))))))))))))))))))))) [1]
   lt0(x, Nil) -> False [1]
   g(Cons(x'', xs''), Cons(x', xs)) -> g[Ite][False][Ite](lt0(xs'', Nil), Cons(x'', xs''), Cons(x', xs)) [2]
   g(x, Cons(x', xs)) -> g[Ite][False][Ite](null_lt0, x, Cons(x', xs)) [1]
   f(Cons(x''', xs'''), Cons(x', xs)) -> f(f[Ite][False][Ite](lt0(xs''', Nil), Cons(x''', xs'''), Cons(x', xs)), f[Ite][False][Ite](lt0(xs''', Nil), Cons(x''', xs'''), Cons(x', xs))) [3]
   f(Cons(x''', xs'''), Cons(x', xs)) -> f(f[Ite][False][Ite](lt0(xs''', Nil), Cons(x''', xs'''), Cons(x', xs)), f[Ite][False][Ite](null_lt0, Cons(x''', xs'''), Cons(x', xs))) [2]
   f(Cons(x'1, xs'1), Cons(x', xs)) -> f(f[Ite][False][Ite](null_lt0, Cons(x'1, xs'1), Cons(x', xs)), f[Ite][False][Ite](lt0(xs'1, Nil), Cons(x'1, xs'1), Cons(x', xs))) [2]
   f(x, Cons(x', xs)) -> f(f[Ite][False][Ite](null_lt0, x, Cons(x', xs)), f[Ite][False][Ite](null_lt0, x, Cons(x', xs))) [1]
   number42 -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil)))))))))))))))))))))))))))))))))))))))))) [1]
   goal(x, y) -> Cons(f(x, y), Cons(g(x, y), Nil)) [1]
   g[Ite][False][Ite](False, Cons(x, xs), y) -> g(xs, Cons(Cons(Nil, Nil), y)) [0]
   g[Ite][False][Ite](True, x', Cons(x, xs)) -> g(x', xs) [0]
   f[Ite][False][Ite](False, Cons(x, xs), y) -> xs [0]
   f[Ite][False][Ite](True, x', Cons(x, xs)) -> xs [0]
   f[Ite][False][Ite](False, x, y) -> Cons(Cons(Nil, Nil), y) [0]
   f[Ite][False][Ite](True, x, y) -> x [0]
   g[Ite][False][Ite](v0, v1, v2) -> Nil [0]
   f[Ite][False][Ite](v0, v1, v2) -> Nil [0]
   lt0(v0, v1) -> null_lt0 [0]

The TRS has the following type information:
lt0 :: Cons:Nil -> Cons:Nil -> False:True:null_lt0
Cons :: Cons:Nil -> Cons:Nil -> Cons:Nil
g :: Cons:Nil -> Cons:Nil -> Cons:Nil
Nil :: Cons:Nil
f :: Cons:Nil -> Cons:Nil -> Cons:Nil
False :: False:True:null_lt0
g[Ite][False][Ite] :: False:True:null_lt0 -> Cons:Nil -> Cons:Nil -> Cons:Nil
f[Ite][False][Ite] :: False:True:null_lt0 -> Cons:Nil -> Cons:Nil -> Cons:Nil
number42 :: Cons:Nil
goal :: Cons:Nil -> Cons:Nil -> Cons:Nil
True :: False:True:null_lt0
null_lt0 :: False:True:null_lt0

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

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

   Nil => 0
   False => 1
   True => 2
   null_lt0 => 0

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

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

   f(z, z') -{ 3 }-> f(f[Ite][False][Ite](lt0(xs''', 0), 1 + x''' + xs''', 1 + x' + xs), f[Ite][False][Ite](lt0(xs''', 0), 1 + x''' + xs''', 1 + x' + xs)) :|: xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs'''
   f(z, z') -{ 2 }-> f(f[Ite][False][Ite](lt0(xs''', 0), 1 + x''' + xs''', 1 + x' + xs), f[Ite][False][Ite](0, 1 + x''' + xs''', 1 + x' + xs)) :|: xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs'''
   f(z, z') -{ 1 }-> f(f[Ite][False][Ite](0, x, 1 + x' + xs), f[Ite][False][Ite](0, x, 1 + x' + xs)) :|: xs >= 0, z' = 1 + x' + xs, x >= 0, x' >= 0, z = x
   f(z, z') -{ 2 }-> f(f[Ite][False][Ite](0, 1 + x'1 + xs'1, 1 + x' + xs), f[Ite][False][Ite](lt0(xs'1, 0), 1 + x'1 + xs'1, 1 + x' + xs)) :|: xs >= 0, z' = 1 + x' + xs, x'1 >= 0, x' >= 0, z = 1 + x'1 + xs'1, xs'1 >= 0
   f(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: x >= 0, z = x, z' = 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> x :|: z = 2, z' = x, z'' = y, x >= 0, y >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: xs >= 0, z' = 1 + x + xs, z'' = y, z = 1, x >= 0, y >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, z' = x', xs >= 0, x' >= 0, x >= 0, z'' = 1 + x + xs
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + (1 + 0 + 0) + y :|: z' = x, z'' = y, z = 1, x >= 0, y >= 0
   g(z, z') -{ 2 }-> g[Ite][False][Ite](lt0(xs'', 0), 1 + x'' + xs'', 1 + x' + xs) :|: xs >= 0, z' = 1 + x' + xs, xs'' >= 0, x' >= 0, z = 1 + x'' + xs'', x'' >= 0
   g(z, z') -{ 1 }-> g[Ite][False][Ite](0, x, 1 + x' + xs) :|: xs >= 0, z' = 1 + x' + xs, x >= 0, x' >= 0, z = x
   g(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: x >= 0, z = x, z' = 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(x', xs) :|: z = 2, z' = x', xs >= 0, x' >= 0, x >= 0, z'' = 1 + x + xs
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(xs, 1 + (1 + 0 + 0) + y) :|: xs >= 0, z' = 1 + x + xs, z'' = y, z = 1, x >= 0, y >= 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   goal(z, z') -{ 1 }-> 1 + f(x, y) + (1 + g(x, y) + 0) :|: x >= 0, y >= 0, z = x, z' = y
   lt0(z, z') -{ 1 }-> lt0(xs', xs) :|: xs >= 0, z' = 1 + x + xs, x' >= 0, xs' >= 0, x >= 0, z = 1 + x' + xs'
   lt0(z, z') -{ 1 }-> 1 :|: x >= 0, z = x, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   number42 -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: 


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

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

   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> x :|: z = 2, z' = x, z'' = y, x >= 0, y >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: xs >= 0, z' = 1 + x + xs, z'' = y, z = 1, x >= 0, y >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, z' = x', xs >= 0, x' >= 0, x >= 0, z'' = 1 + x + xs
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + (1 + 0 + 0) + y :|: z' = x, z'' = y, z = 1, x >= 0, y >= 0

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

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

   f(z, z') -{ 3 }-> f(f[Ite][False][Ite](lt0(xs''', 0), 1 + x''' + xs''', 1 + x' + xs), f[Ite][False][Ite](lt0(xs''', 0), 1 + x''' + xs''', 1 + x' + xs)) :|: xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs'''
   f(z, z') -{ 2 }-> f(f[Ite][False][Ite](lt0(xs''', 0), 1 + x''' + xs''', 1 + x' + xs), 0) :|: xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs''', v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x''' + xs''' = v1, v2 >= 0
   f(z, z') -{ 2 }-> f(0, f[Ite][False][Ite](lt0(xs'1, 0), 1 + x'1 + xs'1, 1 + x' + xs)) :|: xs >= 0, z' = 1 + x' + xs, x'1 >= 0, x' >= 0, z = 1 + x'1 + xs'1, xs'1 >= 0, v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x'1 + xs'1 = v1, v2 >= 0
   f(z, z') -{ 1 }-> f(0, 0) :|: xs >= 0, z' = 1 + x' + xs, x >= 0, x' >= 0, z = x, v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, x = v1, v2 >= 0, v0' >= 0, 1 + x' + xs = v2', v1' >= 0, 0 = v0', x = v1', v2' >= 0
   f(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: x >= 0, z = x, z' = 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> x :|: z = 2, z' = x, z'' = y, x >= 0, y >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: xs >= 0, z' = 1 + x + xs, z'' = y, z = 1, x >= 0, y >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, z' = x', xs >= 0, x' >= 0, x >= 0, z'' = 1 + x + xs
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + (1 + 0 + 0) + y :|: z' = x, z'' = y, z = 1, x >= 0, y >= 0
   g(z, z') -{ 2 }-> g[Ite][False][Ite](lt0(xs'', 0), 1 + x'' + xs'', 1 + x' + xs) :|: xs >= 0, z' = 1 + x' + xs, xs'' >= 0, x' >= 0, z = 1 + x'' + xs'', x'' >= 0
   g(z, z') -{ 1 }-> g[Ite][False][Ite](0, x, 1 + x' + xs) :|: xs >= 0, z' = 1 + x' + xs, x >= 0, x' >= 0, z = x
   g(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: x >= 0, z = x, z' = 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(x', xs) :|: z = 2, z' = x', xs >= 0, x' >= 0, x >= 0, z'' = 1 + x + xs
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(xs, 1 + (1 + 0 + 0) + y) :|: xs >= 0, z' = 1 + x + xs, z'' = y, z = 1, x >= 0, y >= 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   goal(z, z') -{ 1 }-> 1 + f(x, y) + (1 + g(x, y) + 0) :|: x >= 0, y >= 0, z = x, z' = y
   lt0(z, z') -{ 1 }-> lt0(xs', xs) :|: xs >= 0, z' = 1 + x + xs, x' >= 0, xs' >= 0, x >= 0, z = 1 + x' + xs'
   lt0(z, z') -{ 1 }-> 1 :|: x >= 0, z = x, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   number42 -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: 


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

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

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

   f(z, z') -{ 3 }-> f(f[Ite][False][Ite](lt0(xs''', 0), 1 + x''' + xs''', 1 + x' + xs), f[Ite][False][Ite](lt0(xs''', 0), 1 + x''' + xs''', 1 + x' + xs)) :|: xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs'''
   f(z, z') -{ 2 }-> f(f[Ite][False][Ite](lt0(xs''', 0), 1 + x''' + xs''', 1 + x' + xs), 0) :|: xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs''', v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x''' + xs''' = v1, v2 >= 0
   f(z, z') -{ 2 }-> f(0, f[Ite][False][Ite](lt0(xs'1, 0), 1 + x'1 + xs'1, 1 + x' + xs)) :|: xs >= 0, z' = 1 + x' + xs, x'1 >= 0, x' >= 0, z = 1 + x'1 + xs'1, xs'1 >= 0, v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x'1 + xs'1 = v1, v2 >= 0
   f(z, z') -{ 1 }-> f(0, 0) :|: xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0, v0 >= 0, 1 + x' + xs = v2, 0 = v0, v2 >= 0, v0' >= 0, 1 + x' + xs = v2', 0 = v0', v2' >= 0
   f(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + (1 + 0 + 0) + z'' :|: z = 1, z' >= 0, z'' >= 0
   g(z, z') -{ 2 }-> g[Ite][False][Ite](lt0(xs'', 0), 1 + x'' + xs'', 1 + x' + xs) :|: xs >= 0, z' = 1 + x' + xs, xs'' >= 0, x' >= 0, z = 1 + x'' + xs'', x'' >= 0
   g(z, z') -{ 1 }-> g[Ite][False][Ite](0, z, 1 + x' + xs) :|: xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0
   g(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(xs, 1 + (1 + 0 + 0) + z'') :|: xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(z', xs) :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   goal(z, z') -{ 1 }-> 1 + f(z, z') + (1 + g(z, z') + 0) :|: z >= 0, z' >= 0
   lt0(z, z') -{ 1 }-> lt0(xs', xs) :|: xs >= 0, z' = 1 + x + xs, x' >= 0, xs' >= 0, x >= 0, z = 1 + x' + xs'
   lt0(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   number42 -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: 


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

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

   { number42 }
   { lt0 }
   { f[Ite][False][Ite] }
   { g[Ite][False][Ite], g }
   { f }
   { goal }

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

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

   f(z, z') -{ 3 }-> f(f[Ite][False][Ite](lt0(xs''', 0), 1 + x''' + xs''', 1 + x' + xs), f[Ite][False][Ite](lt0(xs''', 0), 1 + x''' + xs''', 1 + x' + xs)) :|: xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs'''
   f(z, z') -{ 2 }-> f(f[Ite][False][Ite](lt0(xs''', 0), 1 + x''' + xs''', 1 + x' + xs), 0) :|: xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs''', v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x''' + xs''' = v1, v2 >= 0
   f(z, z') -{ 2 }-> f(0, f[Ite][False][Ite](lt0(xs'1, 0), 1 + x'1 + xs'1, 1 + x' + xs)) :|: xs >= 0, z' = 1 + x' + xs, x'1 >= 0, x' >= 0, z = 1 + x'1 + xs'1, xs'1 >= 0, v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x'1 + xs'1 = v1, v2 >= 0
   f(z, z') -{ 1 }-> f(0, 0) :|: xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0, v0 >= 0, 1 + x' + xs = v2, 0 = v0, v2 >= 0, v0' >= 0, 1 + x' + xs = v2', 0 = v0', v2' >= 0
   f(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + (1 + 0 + 0) + z'' :|: z = 1, z' >= 0, z'' >= 0
   g(z, z') -{ 2 }-> g[Ite][False][Ite](lt0(xs'', 0), 1 + x'' + xs'', 1 + x' + xs) :|: xs >= 0, z' = 1 + x' + xs, xs'' >= 0, x' >= 0, z = 1 + x'' + xs'', x'' >= 0
   g(z, z') -{ 1 }-> g[Ite][False][Ite](0, z, 1 + x' + xs) :|: xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0
   g(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(xs, 1 + (1 + 0 + 0) + z'') :|: xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(z', xs) :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   goal(z, z') -{ 1 }-> 1 + f(z, z') + (1 + g(z, z') + 0) :|: z >= 0, z' >= 0
   lt0(z, z') -{ 1 }-> lt0(xs', xs) :|: xs >= 0, z' = 1 + x + xs, x' >= 0, xs' >= 0, x >= 0, z = 1 + x' + xs'
   lt0(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   number42 -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: 

Function symbols to be analyzed: {number42}, {lt0}, {f[Ite][False][Ite]}, {g[Ite][False][Ite],g}, {f}, {goal}

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

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

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

   f(z, z') -{ 3 }-> f(f[Ite][False][Ite](lt0(xs''', 0), 1 + x''' + xs''', 1 + x' + xs), f[Ite][False][Ite](lt0(xs''', 0), 1 + x''' + xs''', 1 + x' + xs)) :|: xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs'''
   f(z, z') -{ 2 }-> f(f[Ite][False][Ite](lt0(xs''', 0), 1 + x''' + xs''', 1 + x' + xs), 0) :|: xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs''', v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x''' + xs''' = v1, v2 >= 0
   f(z, z') -{ 2 }-> f(0, f[Ite][False][Ite](lt0(xs'1, 0), 1 + x'1 + xs'1, 1 + x' + xs)) :|: xs >= 0, z' = 1 + x' + xs, x'1 >= 0, x' >= 0, z = 1 + x'1 + xs'1, xs'1 >= 0, v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x'1 + xs'1 = v1, v2 >= 0
   f(z, z') -{ 1 }-> f(0, 0) :|: xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0, v0 >= 0, 1 + x' + xs = v2, 0 = v0, v2 >= 0, v0' >= 0, 1 + x' + xs = v2', 0 = v0', v2' >= 0
   f(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + (1 + 0 + 0) + z'' :|: z = 1, z' >= 0, z'' >= 0
   g(z, z') -{ 2 }-> g[Ite][False][Ite](lt0(xs'', 0), 1 + x'' + xs'', 1 + x' + xs) :|: xs >= 0, z' = 1 + x' + xs, xs'' >= 0, x' >= 0, z = 1 + x'' + xs'', x'' >= 0
   g(z, z') -{ 1 }-> g[Ite][False][Ite](0, z, 1 + x' + xs) :|: xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0
   g(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(xs, 1 + (1 + 0 + 0) + z'') :|: xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(z', xs) :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   goal(z, z') -{ 1 }-> 1 + f(z, z') + (1 + g(z, z') + 0) :|: z >= 0, z' >= 0
   lt0(z, z') -{ 1 }-> lt0(xs', xs) :|: xs >= 0, z' = 1 + x + xs, x' >= 0, xs' >= 0, x >= 0, z = 1 + x' + xs'
   lt0(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   number42 -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: 

Function symbols to be analyzed: {number42}, {lt0}, {f[Ite][False][Ite]}, {g[Ite][False][Ite],g}, {f}, {goal}

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

(25) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   f(z, z') -{ 3 }-> f(f[Ite][False][Ite](lt0(xs''', 0), 1 + x''' + xs''', 1 + x' + xs), f[Ite][False][Ite](lt0(xs''', 0), 1 + x''' + xs''', 1 + x' + xs)) :|: xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs'''
   f(z, z') -{ 2 }-> f(f[Ite][False][Ite](lt0(xs''', 0), 1 + x''' + xs''', 1 + x' + xs), 0) :|: xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs''', v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x''' + xs''' = v1, v2 >= 0
   f(z, z') -{ 2 }-> f(0, f[Ite][False][Ite](lt0(xs'1, 0), 1 + x'1 + xs'1, 1 + x' + xs)) :|: xs >= 0, z' = 1 + x' + xs, x'1 >= 0, x' >= 0, z = 1 + x'1 + xs'1, xs'1 >= 0, v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x'1 + xs'1 = v1, v2 >= 0
   f(z, z') -{ 1 }-> f(0, 0) :|: xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0, v0 >= 0, 1 + x' + xs = v2, 0 = v0, v2 >= 0, v0' >= 0, 1 + x' + xs = v2', 0 = v0', v2' >= 0
   f(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + (1 + 0 + 0) + z'' :|: z = 1, z' >= 0, z'' >= 0
   g(z, z') -{ 2 }-> g[Ite][False][Ite](lt0(xs'', 0), 1 + x'' + xs'', 1 + x' + xs) :|: xs >= 0, z' = 1 + x' + xs, xs'' >= 0, x' >= 0, z = 1 + x'' + xs'', x'' >= 0
   g(z, z') -{ 1 }-> g[Ite][False][Ite](0, z, 1 + x' + xs) :|: xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0
   g(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(xs, 1 + (1 + 0 + 0) + z'') :|: xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(z', xs) :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   goal(z, z') -{ 1 }-> 1 + f(z, z') + (1 + g(z, z') + 0) :|: z >= 0, z' >= 0
   lt0(z, z') -{ 1 }-> lt0(xs', xs) :|: xs >= 0, z' = 1 + x + xs, x' >= 0, xs' >= 0, x >= 0, z = 1 + x' + xs'
   lt0(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   number42 -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: 

Function symbols to be analyzed: {number42}, {lt0}, {f[Ite][False][Ite]}, {g[Ite][False][Ite],g}, {f}, {goal}
Previous analysis results are:
  number42: runtime: ?, size: O(1) [42]

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

(27) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   f(z, z') -{ 3 }-> f(f[Ite][False][Ite](lt0(xs''', 0), 1 + x''' + xs''', 1 + x' + xs), f[Ite][False][Ite](lt0(xs''', 0), 1 + x''' + xs''', 1 + x' + xs)) :|: xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs'''
   f(z, z') -{ 2 }-> f(f[Ite][False][Ite](lt0(xs''', 0), 1 + x''' + xs''', 1 + x' + xs), 0) :|: xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs''', v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x''' + xs''' = v1, v2 >= 0
   f(z, z') -{ 2 }-> f(0, f[Ite][False][Ite](lt0(xs'1, 0), 1 + x'1 + xs'1, 1 + x' + xs)) :|: xs >= 0, z' = 1 + x' + xs, x'1 >= 0, x' >= 0, z = 1 + x'1 + xs'1, xs'1 >= 0, v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x'1 + xs'1 = v1, v2 >= 0
   f(z, z') -{ 1 }-> f(0, 0) :|: xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0, v0 >= 0, 1 + x' + xs = v2, 0 = v0, v2 >= 0, v0' >= 0, 1 + x' + xs = v2', 0 = v0', v2' >= 0
   f(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + (1 + 0 + 0) + z'' :|: z = 1, z' >= 0, z'' >= 0
   g(z, z') -{ 2 }-> g[Ite][False][Ite](lt0(xs'', 0), 1 + x'' + xs'', 1 + x' + xs) :|: xs >= 0, z' = 1 + x' + xs, xs'' >= 0, x' >= 0, z = 1 + x'' + xs'', x'' >= 0
   g(z, z') -{ 1 }-> g[Ite][False][Ite](0, z, 1 + x' + xs) :|: xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0
   g(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(xs, 1 + (1 + 0 + 0) + z'') :|: xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(z', xs) :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   goal(z, z') -{ 1 }-> 1 + f(z, z') + (1 + g(z, z') + 0) :|: z >= 0, z' >= 0
   lt0(z, z') -{ 1 }-> lt0(xs', xs) :|: xs >= 0, z' = 1 + x + xs, x' >= 0, xs' >= 0, x >= 0, z = 1 + x' + xs'
   lt0(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   number42 -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: 

Function symbols to be analyzed: {lt0}, {f[Ite][False][Ite]}, {g[Ite][False][Ite],g}, {f}, {goal}
Previous analysis results are:
  number42: runtime: O(1) [1], size: O(1) [42]

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

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

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

   f(z, z') -{ 3 }-> f(f[Ite][False][Ite](lt0(xs''', 0), 1 + x''' + xs''', 1 + x' + xs), f[Ite][False][Ite](lt0(xs''', 0), 1 + x''' + xs''', 1 + x' + xs)) :|: xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs'''
   f(z, z') -{ 2 }-> f(f[Ite][False][Ite](lt0(xs''', 0), 1 + x''' + xs''', 1 + x' + xs), 0) :|: xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs''', v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x''' + xs''' = v1, v2 >= 0
   f(z, z') -{ 2 }-> f(0, f[Ite][False][Ite](lt0(xs'1, 0), 1 + x'1 + xs'1, 1 + x' + xs)) :|: xs >= 0, z' = 1 + x' + xs, x'1 >= 0, x' >= 0, z = 1 + x'1 + xs'1, xs'1 >= 0, v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x'1 + xs'1 = v1, v2 >= 0
   f(z, z') -{ 1 }-> f(0, 0) :|: xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0, v0 >= 0, 1 + x' + xs = v2, 0 = v0, v2 >= 0, v0' >= 0, 1 + x' + xs = v2', 0 = v0', v2' >= 0
   f(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + (1 + 0 + 0) + z'' :|: z = 1, z' >= 0, z'' >= 0
   g(z, z') -{ 2 }-> g[Ite][False][Ite](lt0(xs'', 0), 1 + x'' + xs'', 1 + x' + xs) :|: xs >= 0, z' = 1 + x' + xs, xs'' >= 0, x' >= 0, z = 1 + x'' + xs'', x'' >= 0
   g(z, z') -{ 1 }-> g[Ite][False][Ite](0, z, 1 + x' + xs) :|: xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0
   g(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(xs, 1 + (1 + 0 + 0) + z'') :|: xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(z', xs) :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   goal(z, z') -{ 1 }-> 1 + f(z, z') + (1 + g(z, z') + 0) :|: z >= 0, z' >= 0
   lt0(z, z') -{ 1 }-> lt0(xs', xs) :|: xs >= 0, z' = 1 + x + xs, x' >= 0, xs' >= 0, x >= 0, z = 1 + x' + xs'
   lt0(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   number42 -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: 

Function symbols to be analyzed: {lt0}, {f[Ite][False][Ite]}, {g[Ite][False][Ite],g}, {f}, {goal}
Previous analysis results are:
  number42: runtime: O(1) [1], size: O(1) [42]

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

(31) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   f(z, z') -{ 3 }-> f(f[Ite][False][Ite](lt0(xs''', 0), 1 + x''' + xs''', 1 + x' + xs), f[Ite][False][Ite](lt0(xs''', 0), 1 + x''' + xs''', 1 + x' + xs)) :|: xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs'''
   f(z, z') -{ 2 }-> f(f[Ite][False][Ite](lt0(xs''', 0), 1 + x''' + xs''', 1 + x' + xs), 0) :|: xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs''', v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x''' + xs''' = v1, v2 >= 0
   f(z, z') -{ 2 }-> f(0, f[Ite][False][Ite](lt0(xs'1, 0), 1 + x'1 + xs'1, 1 + x' + xs)) :|: xs >= 0, z' = 1 + x' + xs, x'1 >= 0, x' >= 0, z = 1 + x'1 + xs'1, xs'1 >= 0, v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x'1 + xs'1 = v1, v2 >= 0
   f(z, z') -{ 1 }-> f(0, 0) :|: xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0, v0 >= 0, 1 + x' + xs = v2, 0 = v0, v2 >= 0, v0' >= 0, 1 + x' + xs = v2', 0 = v0', v2' >= 0
   f(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + (1 + 0 + 0) + z'' :|: z = 1, z' >= 0, z'' >= 0
   g(z, z') -{ 2 }-> g[Ite][False][Ite](lt0(xs'', 0), 1 + x'' + xs'', 1 + x' + xs) :|: xs >= 0, z' = 1 + x' + xs, xs'' >= 0, x' >= 0, z = 1 + x'' + xs'', x'' >= 0
   g(z, z') -{ 1 }-> g[Ite][False][Ite](0, z, 1 + x' + xs) :|: xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0
   g(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(xs, 1 + (1 + 0 + 0) + z'') :|: xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(z', xs) :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   goal(z, z') -{ 1 }-> 1 + f(z, z') + (1 + g(z, z') + 0) :|: z >= 0, z' >= 0
   lt0(z, z') -{ 1 }-> lt0(xs', xs) :|: xs >= 0, z' = 1 + x + xs, x' >= 0, xs' >= 0, x >= 0, z = 1 + x' + xs'
   lt0(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   number42 -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: 

Function symbols to be analyzed: {lt0}, {f[Ite][False][Ite]}, {g[Ite][False][Ite],g}, {f}, {goal}
Previous analysis results are:
  number42: runtime: O(1) [1], size: O(1) [42]
  lt0: runtime: ?, size: O(1) [1]

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

(33) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   f(z, z') -{ 3 }-> f(f[Ite][False][Ite](lt0(xs''', 0), 1 + x''' + xs''', 1 + x' + xs), f[Ite][False][Ite](lt0(xs''', 0), 1 + x''' + xs''', 1 + x' + xs)) :|: xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs'''
   f(z, z') -{ 2 }-> f(f[Ite][False][Ite](lt0(xs''', 0), 1 + x''' + xs''', 1 + x' + xs), 0) :|: xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs''', v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x''' + xs''' = v1, v2 >= 0
   f(z, z') -{ 2 }-> f(0, f[Ite][False][Ite](lt0(xs'1, 0), 1 + x'1 + xs'1, 1 + x' + xs)) :|: xs >= 0, z' = 1 + x' + xs, x'1 >= 0, x' >= 0, z = 1 + x'1 + xs'1, xs'1 >= 0, v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x'1 + xs'1 = v1, v2 >= 0
   f(z, z') -{ 1 }-> f(0, 0) :|: xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0, v0 >= 0, 1 + x' + xs = v2, 0 = v0, v2 >= 0, v0' >= 0, 1 + x' + xs = v2', 0 = v0', v2' >= 0
   f(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + (1 + 0 + 0) + z'' :|: z = 1, z' >= 0, z'' >= 0
   g(z, z') -{ 2 }-> g[Ite][False][Ite](lt0(xs'', 0), 1 + x'' + xs'', 1 + x' + xs) :|: xs >= 0, z' = 1 + x' + xs, xs'' >= 0, x' >= 0, z = 1 + x'' + xs'', x'' >= 0
   g(z, z') -{ 1 }-> g[Ite][False][Ite](0, z, 1 + x' + xs) :|: xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0
   g(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(xs, 1 + (1 + 0 + 0) + z'') :|: xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(z', xs) :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   goal(z, z') -{ 1 }-> 1 + f(z, z') + (1 + g(z, z') + 0) :|: z >= 0, z' >= 0
   lt0(z, z') -{ 1 }-> lt0(xs', xs) :|: xs >= 0, z' = 1 + x + xs, x' >= 0, xs' >= 0, x >= 0, z = 1 + x' + xs'
   lt0(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   number42 -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: 

Function symbols to be analyzed: {f[Ite][False][Ite]}, {g[Ite][False][Ite],g}, {f}, {goal}
Previous analysis results are:
  number42: runtime: O(1) [1], size: O(1) [42]
  lt0: runtime: O(n^1) [1 + z'], size: O(1) [1]

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

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

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

   f(z, z') -{ 5 }-> f(f[Ite][False][Ite](s'', 1 + x''' + xs''', 1 + x' + xs), f[Ite][False][Ite](s1, 1 + x''' + xs''', 1 + x' + xs)) :|: s'' >= 0, s'' <= 1, s1 >= 0, s1 <= 1, xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs'''
   f(z, z') -{ 3 }-> f(f[Ite][False][Ite](s2, 1 + x''' + xs''', 1 + x' + xs), 0) :|: s2 >= 0, s2 <= 1, xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs''', v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x''' + xs''' = v1, v2 >= 0
   f(z, z') -{ 3 }-> f(0, f[Ite][False][Ite](s3, 1 + x'1 + xs'1, 1 + x' + xs)) :|: s3 >= 0, s3 <= 1, xs >= 0, z' = 1 + x' + xs, x'1 >= 0, x' >= 0, z = 1 + x'1 + xs'1, xs'1 >= 0, v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x'1 + xs'1 = v1, v2 >= 0
   f(z, z') -{ 1 }-> f(0, 0) :|: xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0, v0 >= 0, 1 + x' + xs = v2, 0 = v0, v2 >= 0, v0' >= 0, 1 + x' + xs = v2', 0 = v0', v2' >= 0
   f(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + (1 + 0 + 0) + z'' :|: z = 1, z' >= 0, z'' >= 0
   g(z, z') -{ 3 }-> g[Ite][False][Ite](s', 1 + x'' + xs'', 1 + x' + xs) :|: s' >= 0, s' <= 1, xs >= 0, z' = 1 + x' + xs, xs'' >= 0, x' >= 0, z = 1 + x'' + xs'', x'' >= 0
   g(z, z') -{ 1 }-> g[Ite][False][Ite](0, z, 1 + x' + xs) :|: xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0
   g(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(xs, 1 + (1 + 0 + 0) + z'') :|: xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(z', xs) :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   goal(z, z') -{ 1 }-> 1 + f(z, z') + (1 + g(z, z') + 0) :|: z >= 0, z' >= 0
   lt0(z, z') -{ 2 + xs }-> s :|: s >= 0, s <= 1, xs >= 0, z' = 1 + x + xs, x' >= 0, xs' >= 0, x >= 0, z = 1 + x' + xs'
   lt0(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   number42 -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: 

Function symbols to be analyzed: {f[Ite][False][Ite]}, {g[Ite][False][Ite],g}, {f}, {goal}
Previous analysis results are:
  number42: runtime: O(1) [1], size: O(1) [42]
  lt0: runtime: O(n^1) [1 + z'], size: O(1) [1]

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

(37) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   f(z, z') -{ 5 }-> f(f[Ite][False][Ite](s'', 1 + x''' + xs''', 1 + x' + xs), f[Ite][False][Ite](s1, 1 + x''' + xs''', 1 + x' + xs)) :|: s'' >= 0, s'' <= 1, s1 >= 0, s1 <= 1, xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs'''
   f(z, z') -{ 3 }-> f(f[Ite][False][Ite](s2, 1 + x''' + xs''', 1 + x' + xs), 0) :|: s2 >= 0, s2 <= 1, xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs''', v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x''' + xs''' = v1, v2 >= 0
   f(z, z') -{ 3 }-> f(0, f[Ite][False][Ite](s3, 1 + x'1 + xs'1, 1 + x' + xs)) :|: s3 >= 0, s3 <= 1, xs >= 0, z' = 1 + x' + xs, x'1 >= 0, x' >= 0, z = 1 + x'1 + xs'1, xs'1 >= 0, v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x'1 + xs'1 = v1, v2 >= 0
   f(z, z') -{ 1 }-> f(0, 0) :|: xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0, v0 >= 0, 1 + x' + xs = v2, 0 = v0, v2 >= 0, v0' >= 0, 1 + x' + xs = v2', 0 = v0', v2' >= 0
   f(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + (1 + 0 + 0) + z'' :|: z = 1, z' >= 0, z'' >= 0
   g(z, z') -{ 3 }-> g[Ite][False][Ite](s', 1 + x'' + xs'', 1 + x' + xs) :|: s' >= 0, s' <= 1, xs >= 0, z' = 1 + x' + xs, xs'' >= 0, x' >= 0, z = 1 + x'' + xs'', x'' >= 0
   g(z, z') -{ 1 }-> g[Ite][False][Ite](0, z, 1 + x' + xs) :|: xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0
   g(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(xs, 1 + (1 + 0 + 0) + z'') :|: xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(z', xs) :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   goal(z, z') -{ 1 }-> 1 + f(z, z') + (1 + g(z, z') + 0) :|: z >= 0, z' >= 0
   lt0(z, z') -{ 2 + xs }-> s :|: s >= 0, s <= 1, xs >= 0, z' = 1 + x + xs, x' >= 0, xs' >= 0, x >= 0, z = 1 + x' + xs'
   lt0(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   number42 -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: 

Function symbols to be analyzed: {f[Ite][False][Ite]}, {g[Ite][False][Ite],g}, {f}, {goal}
Previous analysis results are:
  number42: runtime: O(1) [1], size: O(1) [42]
  lt0: runtime: O(n^1) [1 + z'], size: O(1) [1]
  f[Ite][False][Ite]: runtime: ?, size: O(n^1) [2 + z' + z'']

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

(39) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using CoFloCo for: f[Ite][False][Ite]
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 0

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

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

   f(z, z') -{ 5 }-> f(f[Ite][False][Ite](s'', 1 + x''' + xs''', 1 + x' + xs), f[Ite][False][Ite](s1, 1 + x''' + xs''', 1 + x' + xs)) :|: s'' >= 0, s'' <= 1, s1 >= 0, s1 <= 1, xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs'''
   f(z, z') -{ 3 }-> f(f[Ite][False][Ite](s2, 1 + x''' + xs''', 1 + x' + xs), 0) :|: s2 >= 0, s2 <= 1, xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs''', v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x''' + xs''' = v1, v2 >= 0
   f(z, z') -{ 3 }-> f(0, f[Ite][False][Ite](s3, 1 + x'1 + xs'1, 1 + x' + xs)) :|: s3 >= 0, s3 <= 1, xs >= 0, z' = 1 + x' + xs, x'1 >= 0, x' >= 0, z = 1 + x'1 + xs'1, xs'1 >= 0, v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x'1 + xs'1 = v1, v2 >= 0
   f(z, z') -{ 1 }-> f(0, 0) :|: xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0, v0 >= 0, 1 + x' + xs = v2, 0 = v0, v2 >= 0, v0' >= 0, 1 + x' + xs = v2', 0 = v0', v2' >= 0
   f(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + (1 + 0 + 0) + z'' :|: z = 1, z' >= 0, z'' >= 0
   g(z, z') -{ 3 }-> g[Ite][False][Ite](s', 1 + x'' + xs'', 1 + x' + xs) :|: s' >= 0, s' <= 1, xs >= 0, z' = 1 + x' + xs, xs'' >= 0, x' >= 0, z = 1 + x'' + xs'', x'' >= 0
   g(z, z') -{ 1 }-> g[Ite][False][Ite](0, z, 1 + x' + xs) :|: xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0
   g(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(xs, 1 + (1 + 0 + 0) + z'') :|: xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(z', xs) :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   goal(z, z') -{ 1 }-> 1 + f(z, z') + (1 + g(z, z') + 0) :|: z >= 0, z' >= 0
   lt0(z, z') -{ 2 + xs }-> s :|: s >= 0, s <= 1, xs >= 0, z' = 1 + x + xs, x' >= 0, xs' >= 0, x >= 0, z = 1 + x' + xs'
   lt0(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   number42 -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: 

Function symbols to be analyzed: {g[Ite][False][Ite],g}, {f}, {goal}
Previous analysis results are:
  number42: runtime: O(1) [1], size: O(1) [42]
  lt0: runtime: O(n^1) [1 + z'], size: O(1) [1]
  f[Ite][False][Ite]: runtime: O(1) [0], size: O(n^1) [2 + z' + z'']

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

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

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

   f(z, z') -{ 5 }-> f(s4, s5) :|: s4 >= 0, s4 <= 1 + x' + xs + 2 + (1 + x''' + xs'''), s5 >= 0, s5 <= 1 + x' + xs + 2 + (1 + x''' + xs'''), s'' >= 0, s'' <= 1, s1 >= 0, s1 <= 1, xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs'''
   f(z, z') -{ 3 }-> f(s6, 0) :|: s6 >= 0, s6 <= 1 + x' + xs + 2 + (1 + x''' + xs'''), s2 >= 0, s2 <= 1, xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs''', v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x''' + xs''' = v1, v2 >= 0
   f(z, z') -{ 3 }-> f(0, s7) :|: s7 >= 0, s7 <= 1 + x' + xs + 2 + (1 + x'1 + xs'1), s3 >= 0, s3 <= 1, xs >= 0, z' = 1 + x' + xs, x'1 >= 0, x' >= 0, z = 1 + x'1 + xs'1, xs'1 >= 0, v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x'1 + xs'1 = v1, v2 >= 0
   f(z, z') -{ 1 }-> f(0, 0) :|: xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0, v0 >= 0, 1 + x' + xs = v2, 0 = v0, v2 >= 0, v0' >= 0, 1 + x' + xs = v2', 0 = v0', v2' >= 0
   f(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + (1 + 0 + 0) + z'' :|: z = 1, z' >= 0, z'' >= 0
   g(z, z') -{ 3 }-> g[Ite][False][Ite](s', 1 + x'' + xs'', 1 + x' + xs) :|: s' >= 0, s' <= 1, xs >= 0, z' = 1 + x' + xs, xs'' >= 0, x' >= 0, z = 1 + x'' + xs'', x'' >= 0
   g(z, z') -{ 1 }-> g[Ite][False][Ite](0, z, 1 + x' + xs) :|: xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0
   g(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(xs, 1 + (1 + 0 + 0) + z'') :|: xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(z', xs) :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   goal(z, z') -{ 1 }-> 1 + f(z, z') + (1 + g(z, z') + 0) :|: z >= 0, z' >= 0
   lt0(z, z') -{ 2 + xs }-> s :|: s >= 0, s <= 1, xs >= 0, z' = 1 + x + xs, x' >= 0, xs' >= 0, x >= 0, z = 1 + x' + xs'
   lt0(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   number42 -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: 

Function symbols to be analyzed: {g[Ite][False][Ite],g}, {f}, {goal}
Previous analysis results are:
  number42: runtime: O(1) [1], size: O(1) [42]
  lt0: runtime: O(n^1) [1 + z'], size: O(1) [1]
  f[Ite][False][Ite]: runtime: O(1) [0], size: O(n^1) [2 + z' + z'']

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

(43) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using CoFloCo for: g[Ite][False][Ite]
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 42

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

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

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

   f(z, z') -{ 5 }-> f(s4, s5) :|: s4 >= 0, s4 <= 1 + x' + xs + 2 + (1 + x''' + xs'''), s5 >= 0, s5 <= 1 + x' + xs + 2 + (1 + x''' + xs'''), s'' >= 0, s'' <= 1, s1 >= 0, s1 <= 1, xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs'''
   f(z, z') -{ 3 }-> f(s6, 0) :|: s6 >= 0, s6 <= 1 + x' + xs + 2 + (1 + x''' + xs'''), s2 >= 0, s2 <= 1, xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs''', v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x''' + xs''' = v1, v2 >= 0
   f(z, z') -{ 3 }-> f(0, s7) :|: s7 >= 0, s7 <= 1 + x' + xs + 2 + (1 + x'1 + xs'1), s3 >= 0, s3 <= 1, xs >= 0, z' = 1 + x' + xs, x'1 >= 0, x' >= 0, z = 1 + x'1 + xs'1, xs'1 >= 0, v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x'1 + xs'1 = v1, v2 >= 0
   f(z, z') -{ 1 }-> f(0, 0) :|: xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0, v0 >= 0, 1 + x' + xs = v2, 0 = v0, v2 >= 0, v0' >= 0, 1 + x' + xs = v2', 0 = v0', v2' >= 0
   f(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + (1 + 0 + 0) + z'' :|: z = 1, z' >= 0, z'' >= 0
   g(z, z') -{ 3 }-> g[Ite][False][Ite](s', 1 + x'' + xs'', 1 + x' + xs) :|: s' >= 0, s' <= 1, xs >= 0, z' = 1 + x' + xs, xs'' >= 0, x' >= 0, z = 1 + x'' + xs'', x'' >= 0
   g(z, z') -{ 1 }-> g[Ite][False][Ite](0, z, 1 + x' + xs) :|: xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0
   g(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(xs, 1 + (1 + 0 + 0) + z'') :|: xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(z', xs) :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   goal(z, z') -{ 1 }-> 1 + f(z, z') + (1 + g(z, z') + 0) :|: z >= 0, z' >= 0
   lt0(z, z') -{ 2 + xs }-> s :|: s >= 0, s <= 1, xs >= 0, z' = 1 + x + xs, x' >= 0, xs' >= 0, x >= 0, z = 1 + x' + xs'
   lt0(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   number42 -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: 

Function symbols to be analyzed: {g[Ite][False][Ite],g}, {f}, {goal}
Previous analysis results are:
  number42: runtime: O(1) [1], size: O(1) [42]
  lt0: runtime: O(n^1) [1 + z'], size: O(1) [1]
  f[Ite][False][Ite]: runtime: O(1) [0], size: O(n^1) [2 + z' + z'']
  g[Ite][False][Ite]: runtime: ?, size: O(1) [42]
  g: runtime: ?, size: O(1) [42]

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

(45) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using CoFloCo for: g[Ite][False][Ite]
after applying outer abstraction to obtain an ITS,
resulting in: O(n^1) with polynomial bound: 7 + 3*z'

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

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

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

   f(z, z') -{ 5 }-> f(s4, s5) :|: s4 >= 0, s4 <= 1 + x' + xs + 2 + (1 + x''' + xs'''), s5 >= 0, s5 <= 1 + x' + xs + 2 + (1 + x''' + xs'''), s'' >= 0, s'' <= 1, s1 >= 0, s1 <= 1, xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs'''
   f(z, z') -{ 3 }-> f(s6, 0) :|: s6 >= 0, s6 <= 1 + x' + xs + 2 + (1 + x''' + xs'''), s2 >= 0, s2 <= 1, xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs''', v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x''' + xs''' = v1, v2 >= 0
   f(z, z') -{ 3 }-> f(0, s7) :|: s7 >= 0, s7 <= 1 + x' + xs + 2 + (1 + x'1 + xs'1), s3 >= 0, s3 <= 1, xs >= 0, z' = 1 + x' + xs, x'1 >= 0, x' >= 0, z = 1 + x'1 + xs'1, xs'1 >= 0, v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x'1 + xs'1 = v1, v2 >= 0
   f(z, z') -{ 1 }-> f(0, 0) :|: xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0, v0 >= 0, 1 + x' + xs = v2, 0 = v0, v2 >= 0, v0' >= 0, 1 + x' + xs = v2', 0 = v0', v2' >= 0
   f(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + (1 + 0 + 0) + z'' :|: z = 1, z' >= 0, z'' >= 0
   g(z, z') -{ 3 }-> g[Ite][False][Ite](s', 1 + x'' + xs'', 1 + x' + xs) :|: s' >= 0, s' <= 1, xs >= 0, z' = 1 + x' + xs, xs'' >= 0, x' >= 0, z = 1 + x'' + xs'', x'' >= 0
   g(z, z') -{ 1 }-> g[Ite][False][Ite](0, z, 1 + x' + xs) :|: xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0
   g(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(xs, 1 + (1 + 0 + 0) + z'') :|: xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(z', xs) :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   goal(z, z') -{ 1 }-> 1 + f(z, z') + (1 + g(z, z') + 0) :|: z >= 0, z' >= 0
   lt0(z, z') -{ 2 + xs }-> s :|: s >= 0, s <= 1, xs >= 0, z' = 1 + x + xs, x' >= 0, xs' >= 0, x >= 0, z = 1 + x' + xs'
   lt0(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   number42 -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: 

Function symbols to be analyzed: {f}, {goal}
Previous analysis results are:
  number42: runtime: O(1) [1], size: O(1) [42]
  lt0: runtime: O(n^1) [1 + z'], size: O(1) [1]
  f[Ite][False][Ite]: runtime: O(1) [0], size: O(n^1) [2 + z' + z'']
  g[Ite][False][Ite]: runtime: O(n^1) [7 + 3*z'], size: O(1) [42]
  g: runtime: O(n^1) [10 + 3*z], size: O(1) [42]

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

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

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

   f(z, z') -{ 5 }-> f(s4, s5) :|: s4 >= 0, s4 <= 1 + x' + xs + 2 + (1 + x''' + xs'''), s5 >= 0, s5 <= 1 + x' + xs + 2 + (1 + x''' + xs'''), s'' >= 0, s'' <= 1, s1 >= 0, s1 <= 1, xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs'''
   f(z, z') -{ 3 }-> f(s6, 0) :|: s6 >= 0, s6 <= 1 + x' + xs + 2 + (1 + x''' + xs'''), s2 >= 0, s2 <= 1, xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs''', v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x''' + xs''' = v1, v2 >= 0
   f(z, z') -{ 3 }-> f(0, s7) :|: s7 >= 0, s7 <= 1 + x' + xs + 2 + (1 + x'1 + xs'1), s3 >= 0, s3 <= 1, xs >= 0, z' = 1 + x' + xs, x'1 >= 0, x' >= 0, z = 1 + x'1 + xs'1, xs'1 >= 0, v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x'1 + xs'1 = v1, v2 >= 0
   f(z, z') -{ 1 }-> f(0, 0) :|: xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0, v0 >= 0, 1 + x' + xs = v2, 0 = v0, v2 >= 0, v0' >= 0, 1 + x' + xs = v2', 0 = v0', v2' >= 0
   f(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + (1 + 0 + 0) + z'' :|: z = 1, z' >= 0, z'' >= 0
   g(z, z') -{ 13 + 3*x'' + 3*xs'' }-> s8 :|: s8 >= 0, s8 <= 42, s' >= 0, s' <= 1, xs >= 0, z' = 1 + x' + xs, xs'' >= 0, x' >= 0, z = 1 + x'' + xs'', x'' >= 0
   g(z, z') -{ 8 + 3*z }-> s9 :|: s9 >= 0, s9 <= 42, xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0
   g(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   g[Ite][False][Ite](z, z', z'') -{ 10 + 3*xs }-> s11 :|: s11 >= 0, s11 <= 42, xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   g[Ite][False][Ite](z, z', z'') -{ 10 + 3*z' }-> s12 :|: s12 >= 0, s12 <= 42, z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   goal(z, z') -{ 11 + 3*z }-> 1 + f(z, z') + (1 + s10 + 0) :|: s10 >= 0, s10 <= 42, z >= 0, z' >= 0
   lt0(z, z') -{ 2 + xs }-> s :|: s >= 0, s <= 1, xs >= 0, z' = 1 + x + xs, x' >= 0, xs' >= 0, x >= 0, z = 1 + x' + xs'
   lt0(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   number42 -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: 

Function symbols to be analyzed: {f}, {goal}
Previous analysis results are:
  number42: runtime: O(1) [1], size: O(1) [42]
  lt0: runtime: O(n^1) [1 + z'], size: O(1) [1]
  f[Ite][False][Ite]: runtime: O(1) [0], size: O(n^1) [2 + z' + z'']
  g[Ite][False][Ite]: runtime: O(n^1) [7 + 3*z'], size: O(1) [42]
  g: runtime: O(n^1) [10 + 3*z], size: O(1) [42]

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

(49) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   f(z, z') -{ 5 }-> f(s4, s5) :|: s4 >= 0, s4 <= 1 + x' + xs + 2 + (1 + x''' + xs'''), s5 >= 0, s5 <= 1 + x' + xs + 2 + (1 + x''' + xs'''), s'' >= 0, s'' <= 1, s1 >= 0, s1 <= 1, xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs'''
   f(z, z') -{ 3 }-> f(s6, 0) :|: s6 >= 0, s6 <= 1 + x' + xs + 2 + (1 + x''' + xs'''), s2 >= 0, s2 <= 1, xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs''', v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x''' + xs''' = v1, v2 >= 0
   f(z, z') -{ 3 }-> f(0, s7) :|: s7 >= 0, s7 <= 1 + x' + xs + 2 + (1 + x'1 + xs'1), s3 >= 0, s3 <= 1, xs >= 0, z' = 1 + x' + xs, x'1 >= 0, x' >= 0, z = 1 + x'1 + xs'1, xs'1 >= 0, v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x'1 + xs'1 = v1, v2 >= 0
   f(z, z') -{ 1 }-> f(0, 0) :|: xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0, v0 >= 0, 1 + x' + xs = v2, 0 = v0, v2 >= 0, v0' >= 0, 1 + x' + xs = v2', 0 = v0', v2' >= 0
   f(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + (1 + 0 + 0) + z'' :|: z = 1, z' >= 0, z'' >= 0
   g(z, z') -{ 13 + 3*x'' + 3*xs'' }-> s8 :|: s8 >= 0, s8 <= 42, s' >= 0, s' <= 1, xs >= 0, z' = 1 + x' + xs, xs'' >= 0, x' >= 0, z = 1 + x'' + xs'', x'' >= 0
   g(z, z') -{ 8 + 3*z }-> s9 :|: s9 >= 0, s9 <= 42, xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0
   g(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   g[Ite][False][Ite](z, z', z'') -{ 10 + 3*xs }-> s11 :|: s11 >= 0, s11 <= 42, xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   g[Ite][False][Ite](z, z', z'') -{ 10 + 3*z' }-> s12 :|: s12 >= 0, s12 <= 42, z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   goal(z, z') -{ 11 + 3*z }-> 1 + f(z, z') + (1 + s10 + 0) :|: s10 >= 0, s10 <= 42, z >= 0, z' >= 0
   lt0(z, z') -{ 2 + xs }-> s :|: s >= 0, s <= 1, xs >= 0, z' = 1 + x + xs, x' >= 0, xs' >= 0, x >= 0, z = 1 + x' + xs'
   lt0(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   number42 -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: 

Function symbols to be analyzed: {f}, {goal}
Previous analysis results are:
  number42: runtime: O(1) [1], size: O(1) [42]
  lt0: runtime: O(n^1) [1 + z'], size: O(1) [1]
  f[Ite][False][Ite]: runtime: O(1) [0], size: O(n^1) [2 + z' + z'']
  g[Ite][False][Ite]: runtime: O(n^1) [7 + 3*z'], size: O(1) [42]
  g: runtime: O(n^1) [10 + 3*z], size: O(1) [42]
  f: runtime: ?, size: O(1) [42]

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

(51) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   f(z, z') -{ 5 }-> f(s4, s5) :|: s4 >= 0, s4 <= 1 + x' + xs + 2 + (1 + x''' + xs'''), s5 >= 0, s5 <= 1 + x' + xs + 2 + (1 + x''' + xs'''), s'' >= 0, s'' <= 1, s1 >= 0, s1 <= 1, xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs'''
   f(z, z') -{ 3 }-> f(s6, 0) :|: s6 >= 0, s6 <= 1 + x' + xs + 2 + (1 + x''' + xs'''), s2 >= 0, s2 <= 1, xs >= 0, z' = 1 + x' + xs, x' >= 0, xs''' >= 0, x''' >= 0, z = 1 + x''' + xs''', v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x''' + xs''' = v1, v2 >= 0
   f(z, z') -{ 3 }-> f(0, s7) :|: s7 >= 0, s7 <= 1 + x' + xs + 2 + (1 + x'1 + xs'1), s3 >= 0, s3 <= 1, xs >= 0, z' = 1 + x' + xs, x'1 >= 0, x' >= 0, z = 1 + x'1 + xs'1, xs'1 >= 0, v0 >= 0, 1 + x' + xs = v2, v1 >= 0, 0 = v0, 1 + x'1 + xs'1 = v1, v2 >= 0
   f(z, z') -{ 1 }-> f(0, 0) :|: xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0, v0 >= 0, 1 + x' + xs = v2, 0 = v0, v2 >= 0, v0' >= 0, 1 + x' + xs = v2', 0 = v0', v2' >= 0
   f(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z' :|: z = 2, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + (1 + 0 + 0) + z'' :|: z = 1, z' >= 0, z'' >= 0
   g(z, z') -{ 13 + 3*x'' + 3*xs'' }-> s8 :|: s8 >= 0, s8 <= 42, s' >= 0, s' <= 1, xs >= 0, z' = 1 + x' + xs, xs'' >= 0, x' >= 0, z = 1 + x'' + xs'', x'' >= 0
   g(z, z') -{ 8 + 3*z }-> s9 :|: s9 >= 0, s9 <= 42, xs >= 0, z' = 1 + x' + xs, z >= 0, x' >= 0
   g(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: z >= 0, z' = 0
   g[Ite][False][Ite](z, z', z'') -{ 10 + 3*xs }-> s11 :|: s11 >= 0, s11 <= 42, xs >= 0, z' = 1 + x + xs, z = 1, x >= 0, z'' >= 0
   g[Ite][False][Ite](z, z', z'') -{ 10 + 3*z' }-> s12 :|: s12 >= 0, s12 <= 42, z = 2, xs >= 0, z' >= 0, x >= 0, z'' = 1 + x + xs
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   goal(z, z') -{ 11 + 3*z }-> 1 + f(z, z') + (1 + s10 + 0) :|: s10 >= 0, s10 <= 42, z >= 0, z' >= 0
   lt0(z, z') -{ 2 + xs }-> s :|: s >= 0, s <= 1, xs >= 0, z' = 1 + x + xs, x' >= 0, xs' >= 0, x >= 0, z = 1 + x' + xs'
   lt0(z, z') -{ 1 }-> 1 :|: z >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   number42 -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: 

Function symbols to be analyzed: {f}, {goal}
Previous analysis results are:
  number42: runtime: O(1) [1], size: O(1) [42]
  lt0: runtime: O(n^1) [1 + z'], size: O(1) [1]
  f[Ite][False][Ite]: runtime: O(1) [0], size: O(n^1) [2 + z' + z'']
  g[Ite][False][Ite]: runtime: O(n^1) [7 + 3*z'], size: O(1) [42]
  g: runtime: O(n^1) [10 + 3*z], size: O(1) [42]
  f: runtime: INF, size: O(1) [42]

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

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

   g[Ite][False][Ite](v0, v1, v2) -> null_g[Ite][False][Ite] [0]
   f[Ite][False][Ite](v0, v1, v2) -> null_f[Ite][False][Ite] [0]
   lt0(v0, v1) -> null_lt0 [0]
   g(v0, v1) -> null_g [0]
   f(v0, v1) -> null_f [0]

And the following fresh constants:    null_g[Ite][False][Ite], null_f[Ite][False][Ite], null_lt0, null_g, null_f

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

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

   lt0(Cons(x', xs'), Cons(x, xs)) -> lt0(xs', xs) [1]
   g(x, Nil) -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil)))))))))))))))))))))))))))))))))))))))))) [1]
   f(x, Nil) -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil)))))))))))))))))))))))))))))))))))))))))) [1]
   lt0(x, Nil) -> False [1]
   g(x, Cons(x', xs)) -> g[Ite][False][Ite](lt0(x, Cons(Nil, Nil)), x, Cons(x', xs)) [1]
   f(x, Cons(x', xs)) -> f(f[Ite][False][Ite](lt0(x, Cons(Nil, Nil)), x, Cons(x', xs)), f[Ite][False][Ite](lt0(x, Cons(Nil, Nil)), x, Cons(x', xs))) [1]
   number42 -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil)))))))))))))))))))))))))))))))))))))))))) [1]
   goal(x, y) -> Cons(f(x, y), Cons(g(x, y), Nil)) [1]
   g[Ite][False][Ite](False, Cons(x, xs), y) -> g(xs, Cons(Cons(Nil, Nil), y)) [0]
   g[Ite][False][Ite](True, x', Cons(x, xs)) -> g(x', xs) [0]
   f[Ite][False][Ite](False, Cons(x, xs), y) -> xs [0]
   f[Ite][False][Ite](True, x', Cons(x, xs)) -> xs [0]
   f[Ite][False][Ite](False, x, y) -> Cons(Cons(Nil, Nil), y) [0]
   f[Ite][False][Ite](True, x, y) -> x [0]
   g[Ite][False][Ite](v0, v1, v2) -> null_g[Ite][False][Ite] [0]
   f[Ite][False][Ite](v0, v1, v2) -> null_f[Ite][False][Ite] [0]
   lt0(v0, v1) -> null_lt0 [0]
   g(v0, v1) -> null_g [0]
   f(v0, v1) -> null_f [0]

The TRS has the following type information:
lt0 :: Cons:Nil:null_g[Ite][False][Ite]:null_f[Ite][False][Ite]:null_g:null_f -> Cons:Nil:null_g[Ite][False][Ite]:null_f[Ite][False][Ite]:null_g:null_f -> False:True:null_lt0
Cons :: Cons:Nil:null_g[Ite][False][Ite]:null_f[Ite][False][Ite]:null_g:null_f -> Cons:Nil:null_g[Ite][False][Ite]:null_f[Ite][False][Ite]:null_g:null_f -> Cons:Nil:null_g[Ite][False][Ite]:null_f[Ite][False][Ite]:null_g:null_f
g :: Cons:Nil:null_g[Ite][False][Ite]:null_f[Ite][False][Ite]:null_g:null_f -> Cons:Nil:null_g[Ite][False][Ite]:null_f[Ite][False][Ite]:null_g:null_f -> Cons:Nil:null_g[Ite][False][Ite]:null_f[Ite][False][Ite]:null_g:null_f
Nil :: Cons:Nil:null_g[Ite][False][Ite]:null_f[Ite][False][Ite]:null_g:null_f
f :: Cons:Nil:null_g[Ite][False][Ite]:null_f[Ite][False][Ite]:null_g:null_f -> Cons:Nil:null_g[Ite][False][Ite]:null_f[Ite][False][Ite]:null_g:null_f -> Cons:Nil:null_g[Ite][False][Ite]:null_f[Ite][False][Ite]:null_g:null_f
False :: False:True:null_lt0
g[Ite][False][Ite] :: False:True:null_lt0 -> Cons:Nil:null_g[Ite][False][Ite]:null_f[Ite][False][Ite]:null_g:null_f -> Cons:Nil:null_g[Ite][False][Ite]:null_f[Ite][False][Ite]:null_g:null_f -> Cons:Nil:null_g[Ite][False][Ite]:null_f[Ite][False][Ite]:null_g:null_f
f[Ite][False][Ite] :: False:True:null_lt0 -> Cons:Nil:null_g[Ite][False][Ite]:null_f[Ite][False][Ite]:null_g:null_f -> Cons:Nil:null_g[Ite][False][Ite]:null_f[Ite][False][Ite]:null_g:null_f -> Cons:Nil:null_g[Ite][False][Ite]:null_f[Ite][False][Ite]:null_g:null_f
number42 :: Cons:Nil:null_g[Ite][False][Ite]:null_f[Ite][False][Ite]:null_g:null_f
goal :: Cons:Nil:null_g[Ite][False][Ite]:null_f[Ite][False][Ite]:null_g:null_f -> Cons:Nil:null_g[Ite][False][Ite]:null_f[Ite][False][Ite]:null_g:null_f -> Cons:Nil:null_g[Ite][False][Ite]:null_f[Ite][False][Ite]:null_g:null_f
True :: False:True:null_lt0
null_g[Ite][False][Ite] :: Cons:Nil:null_g[Ite][False][Ite]:null_f[Ite][False][Ite]:null_g:null_f
null_f[Ite][False][Ite] :: Cons:Nil:null_g[Ite][False][Ite]:null_f[Ite][False][Ite]:null_g:null_f
null_lt0 :: False:True:null_lt0
null_g :: Cons:Nil:null_g[Ite][False][Ite]:null_f[Ite][False][Ite]:null_g:null_f
null_f :: Cons:Nil:null_g[Ite][False][Ite]:null_f[Ite][False][Ite]:null_g:null_f

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

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

   Nil => 0
   False => 1
   True => 2
   null_g[Ite][False][Ite] => 0
   null_f[Ite][False][Ite] => 0
   null_lt0 => 0
   null_g => 0
   null_f => 0

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

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

   f(z, z') -{ 1 }-> f(f[Ite][False][Ite](lt0(x, 1 + 0 + 0), x, 1 + x' + xs), f[Ite][False][Ite](lt0(x, 1 + 0 + 0), x, 1 + x' + xs)) :|: xs >= 0, z' = 1 + x' + xs, x >= 0, x' >= 0, z = x
   f(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   f(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: x >= 0, z = x, z' = 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> x :|: z = 2, z' = x, z'' = y, x >= 0, y >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: xs >= 0, z' = 1 + x + xs, z'' = y, z = 1, x >= 0, y >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> xs :|: z = 2, z' = x', xs >= 0, x' >= 0, x >= 0, z'' = 1 + x + xs
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> 1 + (1 + 0 + 0) + y :|: z' = x, z'' = y, z = 1, x >= 0, y >= 0
   g(z, z') -{ 1 }-> g[Ite][False][Ite](lt0(x, 1 + 0 + 0), x, 1 + x' + xs) :|: xs >= 0, z' = 1 + x' + xs, x >= 0, x' >= 0, z = x
   g(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   g(z, z') -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: x >= 0, z = x, z' = 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(x', xs) :|: z = 2, z' = x', xs >= 0, x' >= 0, x >= 0, z'' = 1 + x + xs
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> g(xs, 1 + (1 + 0 + 0) + y) :|: xs >= 0, z' = 1 + x + xs, z'' = y, z = 1, x >= 0, y >= 0
   g[Ite][False][Ite](z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   goal(z, z') -{ 1 }-> 1 + f(x, y) + (1 + g(x, y) + 0) :|: x >= 0, y >= 0, z = x, z' = y
   lt0(z, z') -{ 1 }-> lt0(xs', xs) :|: xs >= 0, z' = 1 + x + xs, x' >= 0, xs' >= 0, x >= 0, z = 1 + x' + xs'
   lt0(z, z') -{ 1 }-> 1 :|: x >= 0, z = x, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   number42 -{ 1 }-> 1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + (1 + 0 + 0))))))))))))))))))))))))))))))))))))))))) :|: 

Only complete derivations are relevant for the runtime complexity.

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

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

(58)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g[Ite][False][Ite](False, Cons(z0, z1), z2) -> g(z1, Cons(Cons(Nil, Nil), z2))
   g[Ite][False][Ite](True, z0, Cons(z1, z2)) -> g(z0, z2)
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
   lt0(Cons(z0, z1), Cons(z2, z3)) -> lt0(z1, z3)
   lt0(z0, Nil) -> False
   g(z0, Nil) -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil))))))))))))))))))))))))))))))))))))))))))
   g(z0, Cons(z1, z2)) -> g[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))
   f(z0, Nil) -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil))))))))))))))))))))))))))))))))))))))))))
   f(z0, Cons(z1, z2)) -> f(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)))
   number42 -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil))))))))))))))))))))))))))))))))))))))))))
   goal(z0, z1) -> Cons(f(z0, z1), Cons(g(z0, z1), Nil))
Tuples:
   G[ITE][FALSE][ITE](False, Cons(z0, z1), z2) -> c(G(z1, Cons(Cons(Nil, Nil), z2)))
   G[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c1(G(z0, z2))
   F[ITE][FALSE][ITE](False, Cons(z0, z1), z2) -> c2
   F[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c3
   F[ITE][FALSE][ITE](False, z0, z1) -> c4
   F[ITE][FALSE][ITE](True, z0, z1) -> c5
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   LT0(z0, Nil) -> c7
   G(z0, Nil) -> c8
   G(z0, Cons(z1, z2)) -> c9(G[ITE][FALSE][ITE](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), LT0(z0, Cons(Nil, Nil)))
   F(z0, Nil) -> c10
   F(z0, Cons(z1, z2)) -> c11(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), F[ITE][FALSE][ITE](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), LT0(z0, Cons(Nil, Nil)))
   F(z0, Cons(z1, z2)) -> c12(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), F[ITE][FALSE][ITE](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), LT0(z0, Cons(Nil, Nil)))
   NUMBER42 -> c13
   GOAL(z0, z1) -> c14(F(z0, z1))
   GOAL(z0, z1) -> c15(G(z0, z1))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   LT0(z0, Nil) -> c7
   G(z0, Nil) -> c8
   G(z0, Cons(z1, z2)) -> c9(G[ITE][FALSE][ITE](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), LT0(z0, Cons(Nil, Nil)))
   F(z0, Nil) -> c10
   F(z0, Cons(z1, z2)) -> c11(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), F[ITE][FALSE][ITE](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), LT0(z0, Cons(Nil, Nil)))
   F(z0, Cons(z1, z2)) -> c12(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), F[ITE][FALSE][ITE](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), LT0(z0, Cons(Nil, Nil)))
   NUMBER42 -> c13
   GOAL(z0, z1) -> c14(F(z0, z1))
   GOAL(z0, z1) -> c15(G(z0, z1))
K tuples:none
Defined Rule Symbols:   lt0_2, g_2, f_2, number42, goal_2, g[Ite][False][Ite]_3, f[Ite][False][Ite]_3

Defined Pair Symbols:   G[ITE][FALSE][ITE]_3, F[ITE][FALSE][ITE]_3, LT0_2, G_2, F_2, NUMBER42, GOAL_2

Compound Symbols:   c_1, c1_1, c2, c3, c4, c5, c6_1, c7, c8, c9_2, c10, c11_3, c12_3, c13, c14_1, c15_1


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

(59) CdtLeafRemovalProof (ComplexityIfPolyImplication)
Removed 2 leading nodes:
   GOAL(z0, z1) -> c15(G(z0, z1))
   GOAL(z0, z1) -> c14(F(z0, z1))
Removed 7 trailing nodes:
   F[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c3
   LT0(z0, Nil) -> c7
   F(z0, Nil) -> c10
   F[ITE][FALSE][ITE](False, z0, z1) -> c4
   F[ITE][FALSE][ITE](True, z0, z1) -> c5
   F[ITE][FALSE][ITE](False, Cons(z0, z1), z2) -> c2
   NUMBER42 -> c13

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

(60)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g[Ite][False][Ite](False, Cons(z0, z1), z2) -> g(z1, Cons(Cons(Nil, Nil), z2))
   g[Ite][False][Ite](True, z0, Cons(z1, z2)) -> g(z0, z2)
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
   lt0(Cons(z0, z1), Cons(z2, z3)) -> lt0(z1, z3)
   lt0(z0, Nil) -> False
   g(z0, Nil) -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil))))))))))))))))))))))))))))))))))))))))))
   g(z0, Cons(z1, z2)) -> g[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))
   f(z0, Nil) -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil))))))))))))))))))))))))))))))))))))))))))
   f(z0, Cons(z1, z2)) -> f(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)))
   number42 -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil))))))))))))))))))))))))))))))))))))))))))
   goal(z0, z1) -> Cons(f(z0, z1), Cons(g(z0, z1), Nil))
Tuples:
   G[ITE][FALSE][ITE](False, Cons(z0, z1), z2) -> c(G(z1, Cons(Cons(Nil, Nil), z2)))
   G[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c1(G(z0, z2))
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G(z0, Nil) -> c8
   G(z0, Cons(z1, z2)) -> c9(G[ITE][FALSE][ITE](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), LT0(z0, Cons(Nil, Nil)))
   F(z0, Cons(z1, z2)) -> c11(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), F[ITE][FALSE][ITE](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), LT0(z0, Cons(Nil, Nil)))
   F(z0, Cons(z1, z2)) -> c12(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), F[ITE][FALSE][ITE](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), LT0(z0, Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G(z0, Nil) -> c8
   G(z0, Cons(z1, z2)) -> c9(G[ITE][FALSE][ITE](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), LT0(z0, Cons(Nil, Nil)))
   F(z0, Cons(z1, z2)) -> c11(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), F[ITE][FALSE][ITE](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), LT0(z0, Cons(Nil, Nil)))
   F(z0, Cons(z1, z2)) -> c12(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), F[ITE][FALSE][ITE](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), LT0(z0, Cons(Nil, Nil)))
K tuples:none
Defined Rule Symbols:   lt0_2, g_2, f_2, number42, goal_2, g[Ite][False][Ite]_3, f[Ite][False][Ite]_3

Defined Pair Symbols:   G[ITE][FALSE][ITE]_3, LT0_2, G_2, F_2

Compound Symbols:   c_1, c1_1, c6_1, c8, c9_2, c11_3, c12_3


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

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

(62)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   g[Ite][False][Ite](False, Cons(z0, z1), z2) -> g(z1, Cons(Cons(Nil, Nil), z2))
   g[Ite][False][Ite](True, z0, Cons(z1, z2)) -> g(z0, z2)
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
   lt0(Cons(z0, z1), Cons(z2, z3)) -> lt0(z1, z3)
   lt0(z0, Nil) -> False
   g(z0, Nil) -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil))))))))))))))))))))))))))))))))))))))))))
   g(z0, Cons(z1, z2)) -> g[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))
   f(z0, Nil) -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil))))))))))))))))))))))))))))))))))))))))))
   f(z0, Cons(z1, z2)) -> f(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)))
   number42 -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil))))))))))))))))))))))))))))))))))))))))))
   goal(z0, z1) -> Cons(f(z0, z1), Cons(g(z0, z1), Nil))
Tuples:
   G[ITE][FALSE][ITE](False, Cons(z0, z1), z2) -> c(G(z1, Cons(Cons(Nil, Nil), z2)))
   G[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c1(G(z0, z2))
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G(z0, Nil) -> c8
   G(z0, Cons(z1, z2)) -> c9(G[ITE][FALSE][ITE](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), LT0(z0, Cons(Nil, Nil)))
   F(z0, Cons(z1, z2)) -> c11(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil)))
   F(z0, Cons(z1, z2)) -> c12(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G(z0, Nil) -> c8
   G(z0, Cons(z1, z2)) -> c9(G[ITE][FALSE][ITE](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), LT0(z0, Cons(Nil, Nil)))
   F(z0, Cons(z1, z2)) -> c11(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil)))
   F(z0, Cons(z1, z2)) -> c12(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil)))
K tuples:none
Defined Rule Symbols:   lt0_2, g_2, f_2, number42, goal_2, g[Ite][False][Ite]_3, f[Ite][False][Ite]_3

Defined Pair Symbols:   G[ITE][FALSE][ITE]_3, LT0_2, G_2, F_2

Compound Symbols:   c_1, c1_1, c6_1, c8, c9_2, c11_2, c12_2


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

(63) CdtUsableRulesProof (BOTH BOUNDS(ID, ID))
The following rules are not usable and were removed:
   g[Ite][False][Ite](False, Cons(z0, z1), z2) -> g(z1, Cons(Cons(Nil, Nil), z2))
   g[Ite][False][Ite](True, z0, Cons(z1, z2)) -> g(z0, z2)
   g(z0, Nil) -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil))))))))))))))))))))))))))))))))))))))))))
   g(z0, Cons(z1, z2)) -> g[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))
   f(z0, Nil) -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil))))))))))))))))))))))))))))))))))))))))))
   f(z0, Cons(z1, z2)) -> f(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)))
   number42 -> Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Cons(Nil, Nil))))))))))))))))))))))))))))))))))))))))))
   goal(z0, z1) -> Cons(f(z0, z1), Cons(g(z0, z1), Nil))

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

(64)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt0(Cons(z0, z1), Cons(z2, z3)) -> lt0(z1, z3)
   lt0(z0, Nil) -> False
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
Tuples:
   G[ITE][FALSE][ITE](False, Cons(z0, z1), z2) -> c(G(z1, Cons(Cons(Nil, Nil), z2)))
   G[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c1(G(z0, z2))
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G(z0, Nil) -> c8
   G(z0, Cons(z1, z2)) -> c9(G[ITE][FALSE][ITE](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), LT0(z0, Cons(Nil, Nil)))
   F(z0, Cons(z1, z2)) -> c11(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil)))
   F(z0, Cons(z1, z2)) -> c12(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G(z0, Nil) -> c8
   G(z0, Cons(z1, z2)) -> c9(G[ITE][FALSE][ITE](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), LT0(z0, Cons(Nil, Nil)))
   F(z0, Cons(z1, z2)) -> c11(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil)))
   F(z0, Cons(z1, z2)) -> c12(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil)))
K tuples:none
Defined Rule Symbols:   lt0_2, f[Ite][False][Ite]_3

Defined Pair Symbols:   G[ITE][FALSE][ITE]_3, LT0_2, G_2, F_2

Compound Symbols:   c_1, c1_1, c6_1, c8, c9_2, c11_2, c12_2


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

(65) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   G(z0, Nil) -> c8
We considered the (Usable) Rules:none
And the Tuples:
   G[ITE][FALSE][ITE](False, Cons(z0, z1), z2) -> c(G(z1, Cons(Cons(Nil, Nil), z2)))
   G[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c1(G(z0, z2))
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G(z0, Nil) -> c8
   G(z0, Cons(z1, z2)) -> c9(G[ITE][FALSE][ITE](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), LT0(z0, Cons(Nil, Nil)))
   F(z0, Cons(z1, z2)) -> c11(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil)))
   F(z0, Cons(z1, z2)) -> c12(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil)))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(Cons(x_1, x_2)) = 0
   POL(F(x_1, x_2)) = 0
   POL(False) = [1]
   POL(G(x_1, x_2)) = [1]
   POL(G[ITE][FALSE][ITE](x_1, x_2, x_3)) = [1] + x_3
   POL(LT0(x_1, x_2)) = 0
   POL(Nil) = 0
   POL(True) = [1]
   POL(c(x_1)) = x_1
   POL(c1(x_1)) = x_1
   POL(c11(x_1, x_2)) = x_1 + x_2
   POL(c12(x_1, x_2)) = x_1 + x_2
   POL(c6(x_1)) = x_1
   POL(c8) = 0
   POL(c9(x_1, x_2)) = x_1 + x_2
   POL(f[Ite][False][Ite](x_1, x_2, x_3)) = [1] + x_1 + x_2 + x_3
   POL(lt0(x_1, x_2)) = [1]

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

(66)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt0(Cons(z0, z1), Cons(z2, z3)) -> lt0(z1, z3)
   lt0(z0, Nil) -> False
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
Tuples:
   G[ITE][FALSE][ITE](False, Cons(z0, z1), z2) -> c(G(z1, Cons(Cons(Nil, Nil), z2)))
   G[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c1(G(z0, z2))
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G(z0, Nil) -> c8
   G(z0, Cons(z1, z2)) -> c9(G[ITE][FALSE][ITE](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), LT0(z0, Cons(Nil, Nil)))
   F(z0, Cons(z1, z2)) -> c11(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil)))
   F(z0, Cons(z1, z2)) -> c12(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G(z0, Cons(z1, z2)) -> c9(G[ITE][FALSE][ITE](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), LT0(z0, Cons(Nil, Nil)))
   F(z0, Cons(z1, z2)) -> c11(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil)))
   F(z0, Cons(z1, z2)) -> c12(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil)))
K tuples:
   G(z0, Nil) -> c8
Defined Rule Symbols:   lt0_2, f[Ite][False][Ite]_3

Defined Pair Symbols:   G[ITE][FALSE][ITE]_3, LT0_2, G_2, F_2

Compound Symbols:   c_1, c1_1, c6_1, c8, c9_2, c11_2, c12_2


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

(67) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   G(z0, Cons(z1, z2)) -> c9(G[ITE][FALSE][ITE](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), LT0(z0, Cons(Nil, Nil)))
We considered the (Usable) Rules:
   lt0(z0, Nil) -> False
   lt0(Cons(z0, z1), Cons(z2, z3)) -> lt0(z1, z3)
And the Tuples:
   G[ITE][FALSE][ITE](False, Cons(z0, z1), z2) -> c(G(z1, Cons(Cons(Nil, Nil), z2)))
   G[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c1(G(z0, z2))
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G(z0, Nil) -> c8
   G(z0, Cons(z1, z2)) -> c9(G[ITE][FALSE][ITE](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), LT0(z0, Cons(Nil, Nil)))
   F(z0, Cons(z1, z2)) -> c11(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil)))
   F(z0, Cons(z1, z2)) -> c12(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil)))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(Cons(x_1, x_2)) = [1] + x_2
   POL(F(x_1, x_2)) = 0
   POL(False) = 0
   POL(G(x_1, x_2)) = [1] + x_1
   POL(G[ITE][FALSE][ITE](x_1, x_2, x_3)) = x_1 + x_2
   POL(LT0(x_1, x_2)) = 0
   POL(Nil) = 0
   POL(True) = [1]
   POL(c(x_1)) = x_1
   POL(c1(x_1)) = x_1
   POL(c11(x_1, x_2)) = x_1 + x_2
   POL(c12(x_1, x_2)) = x_1 + x_2
   POL(c6(x_1)) = x_1
   POL(c8) = 0
   POL(c9(x_1, x_2)) = x_1 + x_2
   POL(f[Ite][False][Ite](x_1, x_2, x_3)) = [1] + x_1 + x_2 + x_3
   POL(lt0(x_1, x_2)) = 0

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

(68)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt0(Cons(z0, z1), Cons(z2, z3)) -> lt0(z1, z3)
   lt0(z0, Nil) -> False
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
Tuples:
   G[ITE][FALSE][ITE](False, Cons(z0, z1), z2) -> c(G(z1, Cons(Cons(Nil, Nil), z2)))
   G[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c1(G(z0, z2))
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G(z0, Nil) -> c8
   G(z0, Cons(z1, z2)) -> c9(G[ITE][FALSE][ITE](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), LT0(z0, Cons(Nil, Nil)))
   F(z0, Cons(z1, z2)) -> c11(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil)))
   F(z0, Cons(z1, z2)) -> c12(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(z0, Cons(z1, z2)) -> c11(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil)))
   F(z0, Cons(z1, z2)) -> c12(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil)))
K tuples:
   G(z0, Nil) -> c8
   G(z0, Cons(z1, z2)) -> c9(G[ITE][FALSE][ITE](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), LT0(z0, Cons(Nil, Nil)))
Defined Rule Symbols:   lt0_2, f[Ite][False][Ite]_3

Defined Pair Symbols:   G[ITE][FALSE][ITE]_3, LT0_2, G_2, F_2

Compound Symbols:   c_1, c1_1, c6_1, c8, c9_2, c11_2, c12_2


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

(69) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace G(z0, Cons(z1, z2)) -> c9(G[ITE][FALSE][ITE](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), LT0(z0, Cons(Nil, Nil))) by 
   G(Cons(z0, z1), Cons(x1, x2)) -> c9(G[ITE][FALSE][ITE](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2)), LT0(Cons(z0, z1), Cons(Nil, Nil)))

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

(70)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt0(Cons(z0, z1), Cons(z2, z3)) -> lt0(z1, z3)
   lt0(z0, Nil) -> False
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
Tuples:
   G[ITE][FALSE][ITE](False, Cons(z0, z1), z2) -> c(G(z1, Cons(Cons(Nil, Nil), z2)))
   G[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c1(G(z0, z2))
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G(z0, Nil) -> c8
   F(z0, Cons(z1, z2)) -> c11(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil)))
   F(z0, Cons(z1, z2)) -> c12(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil)))
   G(Cons(z0, z1), Cons(x1, x2)) -> c9(G[ITE][FALSE][ITE](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2)), LT0(Cons(z0, z1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(z0, Cons(z1, z2)) -> c11(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil)))
   F(z0, Cons(z1, z2)) -> c12(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil)))
K tuples:
   G(z0, Nil) -> c8
   G(z0, Cons(z1, z2)) -> c9(G[ITE][FALSE][ITE](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), LT0(z0, Cons(Nil, Nil)))
Defined Rule Symbols:   lt0_2, f[Ite][False][Ite]_3

Defined Pair Symbols:   G[ITE][FALSE][ITE]_3, LT0_2, G_2, F_2

Compound Symbols:   c_1, c1_1, c6_1, c8, c11_2, c12_2, c9_2


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

(71) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   G(z0, Nil) -> c8

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

(72)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt0(Cons(z0, z1), Cons(z2, z3)) -> lt0(z1, z3)
   lt0(z0, Nil) -> False
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
Tuples:
   G[ITE][FALSE][ITE](False, Cons(z0, z1), z2) -> c(G(z1, Cons(Cons(Nil, Nil), z2)))
   G[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c1(G(z0, z2))
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(z0, Cons(z1, z2)) -> c11(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil)))
   F(z0, Cons(z1, z2)) -> c12(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil)))
   G(Cons(z0, z1), Cons(x1, x2)) -> c9(G[ITE][FALSE][ITE](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2)), LT0(Cons(z0, z1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(z0, Cons(z1, z2)) -> c11(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil)))
   F(z0, Cons(z1, z2)) -> c12(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil)))
K tuples:none
Defined Rule Symbols:   lt0_2, f[Ite][False][Ite]_3

Defined Pair Symbols:   G[ITE][FALSE][ITE]_3, LT0_2, F_2, G_2

Compound Symbols:   c_1, c1_1, c6_1, c11_2, c12_2, c9_2


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

(73) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace F(z0, Cons(z1, z2)) -> c11(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil))) by 
   F(Cons(z0, z1), Cons(x1, x2)) -> c11(F(f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x1, x2)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))

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

(74)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt0(Cons(z0, z1), Cons(z2, z3)) -> lt0(z1, z3)
   lt0(z0, Nil) -> False
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
Tuples:
   G[ITE][FALSE][ITE](False, Cons(z0, z1), z2) -> c(G(z1, Cons(Cons(Nil, Nil), z2)))
   G[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c1(G(z0, z2))
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(z0, Cons(z1, z2)) -> c12(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil)))
   G(Cons(z0, z1), Cons(x1, x2)) -> c9(G[ITE][FALSE][ITE](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2)), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x1, x2)) -> c11(F(f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x1, x2)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(z0, Cons(z1, z2)) -> c12(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x1, x2)) -> c11(F(f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x1, x2)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
K tuples:none
Defined Rule Symbols:   lt0_2, f[Ite][False][Ite]_3

Defined Pair Symbols:   G[ITE][FALSE][ITE]_3, LT0_2, F_2, G_2

Compound Symbols:   c_1, c1_1, c6_1, c12_2, c9_2, c11_2


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

(75) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace F(z0, Cons(z1, z2)) -> c12(F(f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), f[Ite][False][Ite](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil))) by 
   F(Cons(z0, z1), Cons(x1, x2)) -> c12(F(f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x1, x2)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))

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

(76)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt0(Cons(z0, z1), Cons(z2, z3)) -> lt0(z1, z3)
   lt0(z0, Nil) -> False
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
Tuples:
   G[ITE][FALSE][ITE](False, Cons(z0, z1), z2) -> c(G(z1, Cons(Cons(Nil, Nil), z2)))
   G[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c1(G(z0, z2))
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G(Cons(z0, z1), Cons(x1, x2)) -> c9(G[ITE][FALSE][ITE](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2)), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x1, x2)) -> c11(F(f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x1, x2)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x1, x2)) -> c12(F(f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x1, x2)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(x1, x2)) -> c11(F(f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x1, x2)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x1, x2)) -> c12(F(f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x1, x2)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
K tuples:none
Defined Rule Symbols:   lt0_2, f[Ite][False][Ite]_3

Defined Pair Symbols:   G[ITE][FALSE][ITE]_3, LT0_2, G_2, F_2

Compound Symbols:   c_1, c1_1, c6_1, c9_2, c11_2, c12_2


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

(77) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace G(Cons(z0, z1), Cons(x1, x2)) -> c9(G[ITE][FALSE][ITE](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2)), LT0(Cons(z0, z1), Cons(Nil, Nil))) by 
   G(Cons(x0, z0), Cons(x2, x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x0, z0), Cons(x2, x3)), LT0(Cons(x0, z0), Cons(Nil, Nil)))

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

(78)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt0(Cons(z0, z1), Cons(z2, z3)) -> lt0(z1, z3)
   lt0(z0, Nil) -> False
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
Tuples:
   G[ITE][FALSE][ITE](False, Cons(z0, z1), z2) -> c(G(z1, Cons(Cons(Nil, Nil), z2)))
   G[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c1(G(z0, z2))
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(x1, x2)) -> c11(F(f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x1, x2)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x1, x2)) -> c12(F(f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x1, x2)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   G(Cons(x0, z0), Cons(x2, x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x0, z0), Cons(x2, x3)), LT0(Cons(x0, z0), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(x1, x2)) -> c11(F(f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x1, x2)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x1, x2)) -> c12(F(f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x1, x2)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
K tuples:none
Defined Rule Symbols:   lt0_2, f[Ite][False][Ite]_3

Defined Pair Symbols:   G[ITE][FALSE][ITE]_3, LT0_2, F_2, G_2

Compound Symbols:   c_1, c1_1, c6_1, c11_2, c12_2, c9_2


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

(79) CdtLeafRemovalProof (ComplexityIfPolyImplication)
Removed 1 leading nodes:
   G[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c1(G(z0, z2))

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

(80)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt0(Cons(z0, z1), Cons(z2, z3)) -> lt0(z1, z3)
   lt0(z0, Nil) -> False
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
Tuples:
   G[ITE][FALSE][ITE](False, Cons(z0, z1), z2) -> c(G(z1, Cons(Cons(Nil, Nil), z2)))
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(x1, x2)) -> c11(F(f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x1, x2)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x1, x2)) -> c12(F(f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x1, x2)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   G(Cons(x0, z0), Cons(x2, x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x0, z0), Cons(x2, x3)), LT0(Cons(x0, z0), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(x1, x2)) -> c11(F(f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x1, x2)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x1, x2)) -> c12(F(f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x1, x2)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
K tuples:none
Defined Rule Symbols:   lt0_2, f[Ite][False][Ite]_3

Defined Pair Symbols:   G[ITE][FALSE][ITE]_3, LT0_2, F_2, G_2

Compound Symbols:   c_1, c6_1, c11_2, c12_2, c9_2


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

(81) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace F(Cons(z0, z1), Cons(x1, x2)) -> c11(F(f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil))) by 
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))

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

(82)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt0(Cons(z0, z1), Cons(z2, z3)) -> lt0(z1, z3)
   lt0(z0, Nil) -> False
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
Tuples:
   G[ITE][FALSE][ITE](False, Cons(z0, z1), z2) -> c(G(z1, Cons(Cons(Nil, Nil), z2)))
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(x1, x2)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x1, x2)) -> c12(F(f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x1, x2)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   G(Cons(x0, z0), Cons(x2, x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x0, z0), Cons(x2, x3)), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(x1, x2)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x1, x2)) -> c12(F(f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x1, x2)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
K tuples:none
Defined Rule Symbols:   lt0_2, f[Ite][False][Ite]_3

Defined Pair Symbols:   G[ITE][FALSE][ITE]_3, LT0_2, F_2, G_2

Compound Symbols:   c_1, c6_1, c11_2, c12_2, c9_2


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

(83) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace F(Cons(z0, z1), Cons(x1, x2)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil))) by 
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))

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

(84)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt0(Cons(z0, z1), Cons(z2, z3)) -> lt0(z1, z3)
   lt0(z0, Nil) -> False
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
Tuples:
   G[ITE][FALSE][ITE](False, Cons(z0, z1), z2) -> c(G(z1, Cons(Cons(Nil, Nil), z2)))
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(x1, x2)) -> c12(F(f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x1, x2)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   G(Cons(x0, z0), Cons(x2, x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x0, z0), Cons(x2, x3)), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(x1, x2)) -> c12(F(f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x1, x2)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
K tuples:none
Defined Rule Symbols:   lt0_2, f[Ite][False][Ite]_3

Defined Pair Symbols:   G[ITE][FALSE][ITE]_3, LT0_2, F_2, G_2

Compound Symbols:   c_1, c6_1, c12_2, c9_2, c11_2


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

(85) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace F(Cons(z0, z1), Cons(x1, x2)) -> c12(F(f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil))) by 
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))

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

(86)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt0(Cons(z0, z1), Cons(z2, z3)) -> lt0(z1, z3)
   lt0(z0, Nil) -> False
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
Tuples:
   G[ITE][FALSE][ITE](False, Cons(z0, z1), z2) -> c(G(z1, Cons(Cons(Nil, Nil), z2)))
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(x1, x2)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   G(Cons(x0, z0), Cons(x2, x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x0, z0), Cons(x2, x3)), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(x1, x2)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
K tuples:none
Defined Rule Symbols:   lt0_2, f[Ite][False][Ite]_3

Defined Pair Symbols:   G[ITE][FALSE][ITE]_3, LT0_2, F_2, G_2

Compound Symbols:   c_1, c6_1, c12_2, c9_2, c11_2


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

(87) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace F(Cons(z0, z1), Cons(x1, x2)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x1, x2)), f[Ite][False][Ite](lt0(Cons(z0, z1), Cons(Nil, Nil)), Cons(z0, z1), Cons(x1, x2))), LT0(Cons(z0, z1), Cons(Nil, Nil))) by 
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))

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

(88)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt0(Cons(z0, z1), Cons(z2, z3)) -> lt0(z1, z3)
   lt0(z0, Nil) -> False
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
Tuples:
   G[ITE][FALSE][ITE](False, Cons(z0, z1), z2) -> c(G(z1, Cons(Cons(Nil, Nil), z2)))
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G(Cons(x0, z0), Cons(x2, x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x0, z0), Cons(x2, x3)), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
K tuples:none
Defined Rule Symbols:   lt0_2, f[Ite][False][Ite]_3

Defined Pair Symbols:   G[ITE][FALSE][ITE]_3, LT0_2, G_2, F_2

Compound Symbols:   c_1, c6_1, c9_2, c11_2, c12_2


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

(89) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil))) by F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
----------------------------------------

(90)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt0(Cons(z0, z1), Cons(z2, z3)) -> lt0(z1, z3)
   lt0(z0, Nil) -> False
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
Tuples:
   G[ITE][FALSE][ITE](False, Cons(z0, z1), z2) -> c(G(z1, Cons(Cons(Nil, Nil), z2)))
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G(Cons(x0, z0), Cons(x2, x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x0, z0), Cons(x2, x3)), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
K tuples:none
Defined Rule Symbols:   lt0_2, f[Ite][False][Ite]_3

Defined Pair Symbols:   G[ITE][FALSE][ITE]_3, LT0_2, G_2, F_2

Compound Symbols:   c_1, c6_1, c9_2, c11_2, c12_2


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

(91) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace G[ITE][FALSE][ITE](False, Cons(z0, z1), z2) -> c(G(z1, Cons(Cons(Nil, Nil), z2))) by 
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))

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

(92)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt0(Cons(z0, z1), Cons(z2, z3)) -> lt0(z1, z3)
   lt0(z0, Nil) -> False
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G(Cons(x0, z0), Cons(x2, x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x0, z0), Cons(x2, x3)), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
K tuples:none
Defined Rule Symbols:   lt0_2, f[Ite][False][Ite]_3

Defined Pair Symbols:   LT0_2, G_2, F_2, G[ITE][FALSE][ITE]_3

Compound Symbols:   c6_1, c9_2, c11_2, c12_2, c_1


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

(93) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil))) by F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
----------------------------------------

(94)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt0(Cons(z0, z1), Cons(z2, z3)) -> lt0(z1, z3)
   lt0(z0, Nil) -> False
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G(Cons(x0, z0), Cons(x2, x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x0, z0), Cons(x2, x3)), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
K tuples:none
Defined Rule Symbols:   lt0_2, f[Ite][False][Ite]_3

Defined Pair Symbols:   LT0_2, G_2, F_2, G[ITE][FALSE][ITE]_3

Compound Symbols:   c6_1, c9_2, c11_2, c12_2, c_1


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

(95) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil))) by F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
----------------------------------------

(96)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt0(Cons(z0, z1), Cons(z2, z3)) -> lt0(z1, z3)
   lt0(z0, Nil) -> False
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G(Cons(x0, z0), Cons(x2, x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x0, z0), Cons(x2, x3)), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
K tuples:none
Defined Rule Symbols:   lt0_2, f[Ite][False][Ite]_3

Defined Pair Symbols:   LT0_2, G_2, F_2, G[ITE][FALSE][ITE]_3

Compound Symbols:   c6_1, c9_2, c11_2, c12_2, c_1


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

(97) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil))) by F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
----------------------------------------

(98)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt0(Cons(z0, z1), Cons(z2, z3)) -> lt0(z1, z3)
   lt0(z0, Nil) -> False
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G(Cons(x0, z0), Cons(x2, x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x0, z0), Cons(x2, x3)), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
K tuples:none
Defined Rule Symbols:   lt0_2, f[Ite][False][Ite]_3

Defined Pair Symbols:   LT0_2, G_2, F_2, G[ITE][FALSE][ITE]_3

Compound Symbols:   c6_1, c9_2, c12_2, c11_2, c_1


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

(99) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil))) by F(Cons(z0, z1), Cons(z2, z3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
----------------------------------------

(100)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt0(Cons(z0, z1), Cons(z2, z3)) -> lt0(z1, z3)
   lt0(z0, Nil) -> False
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G(Cons(x0, z0), Cons(x2, x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x0, z0), Cons(x2, x3)), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
K tuples:none
Defined Rule Symbols:   lt0_2, f[Ite][False][Ite]_3

Defined Pair Symbols:   LT0_2, G_2, F_2, G[ITE][FALSE][ITE]_3

Compound Symbols:   c6_1, c9_2, c12_2, c11_2, c_1


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

(101) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace G(Cons(x0, z0), Cons(x2, x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x0, z0), Cons(x2, x3)), LT0(Cons(x0, z0), Cons(Nil, Nil))) by 
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))

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

(102)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt0(Cons(z0, z1), Cons(z2, z3)) -> lt0(z1, z3)
   lt0(z0, Nil) -> False
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
K tuples:none
Defined Rule Symbols:   lt0_2, f[Ite][False][Ite]_3

Defined Pair Symbols:   LT0_2, F_2, G[ITE][FALSE][ITE]_3, G_2

Compound Symbols:   c6_1, c12_2, c11_2, c_1, c9_2


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

(103) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil))) by F(Cons(z0, z1), Cons(z2, z3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
----------------------------------------

(104)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt0(Cons(z0, z1), Cons(z2, z3)) -> lt0(z1, z3)
   lt0(z0, Nil) -> False
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
K tuples:none
Defined Rule Symbols:   lt0_2, f[Ite][False][Ite]_3

Defined Pair Symbols:   LT0_2, F_2, G[ITE][FALSE][ITE]_3, G_2

Compound Symbols:   c6_1, c12_2, c11_2, c_1, c9_2


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

(105) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil))) by F(Cons(z0, z1), Cons(z2, z3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
----------------------------------------

(106)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt0(Cons(z0, z1), Cons(z2, z3)) -> lt0(z1, z3)
   lt0(z0, Nil) -> False
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
K tuples:none
Defined Rule Symbols:   lt0_2, f[Ite][False][Ite]_3

Defined Pair Symbols:   LT0_2, F_2, G[ITE][FALSE][ITE]_3, G_2

Compound Symbols:   c6_1, c12_2, c11_2, c_1, c9_2


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

(107) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](lt0(Cons(x0, z0), Cons(Nil, Nil)), Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil))) by F(Cons(z0, z1), Cons(z2, z3)) -> c12(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
----------------------------------------

(108)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   lt0(Cons(z0, z1), Cons(z2, z3)) -> lt0(z1, z3)
   lt0(z0, Nil) -> False
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c12(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c12(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
K tuples:none
Defined Rule Symbols:   lt0_2, f[Ite][False][Ite]_3

Defined Pair Symbols:   LT0_2, F_2, G[ITE][FALSE][ITE]_3, G_2

Compound Symbols:   c6_1, c11_2, c_1, c12_2, c9_2


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

(109) CdtUsableRulesProof (BOTH BOUNDS(ID, ID))
The following rules are not usable and were removed:
   lt0(Cons(z0, z1), Cons(z2, z3)) -> lt0(z1, z3)

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

(110)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
   lt0(z0, Nil) -> False
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c12(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c12(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
K tuples:none
Defined Rule Symbols:   f[Ite][False][Ite]_3, lt0_2

Defined Pair Symbols:   LT0_2, F_2, G[ITE][FALSE][ITE]_3, G_2

Compound Symbols:   c6_1, c11_2, c_1, c12_2, c9_2


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

(111) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil))) by 
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))

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

(112)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
   lt0(z0, Nil) -> False
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c12(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c12(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
K tuples:none
Defined Rule Symbols:   f[Ite][False][Ite]_3, lt0_2

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, F_2, G_2

Compound Symbols:   c6_1, c_1, c11_2, c12_2, c9_2


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

(113) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace F(Cons(z0, z1), Cons(z2, z3)) -> c11(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil))) by 
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))

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

(114)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
   lt0(z0, Nil) -> False
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c12(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(z2, z3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c12(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
K tuples:none
Defined Rule Symbols:   f[Ite][False][Ite]_3, lt0_2

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, F_2, G_2

Compound Symbols:   c6_1, c_1, c12_2, c9_2, c11_2


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

(115) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace F(Cons(z0, z1), Cons(z2, z3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil))) by 
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))

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

(116)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
   lt0(z0, Nil) -> False
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(z2, z3)) -> c12(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(z2, z3)) -> c12(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
K tuples:none
Defined Rule Symbols:   f[Ite][False][Ite]_3, lt0_2

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c12_2, c11_2


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

(117) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace F(Cons(z0, z1), Cons(z2, z3)) -> c12(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(z2, z3)), f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(z2, z3))), LT0(Cons(z0, z1), Cons(Nil, Nil))) by 
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))

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

(118)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
   lt0(z0, Nil) -> False
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
K tuples:none
Defined Rule Symbols:   f[Ite][False][Ite]_3, lt0_2

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c11_2, c12_2


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

(119) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil))) by 
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))

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

(120)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
   lt0(z0, Nil) -> False
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
K tuples:none
Defined Rule Symbols:   f[Ite][False][Ite]_3, lt0_2

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c11_2, c12_2


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

(121) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil))) by 
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))

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

(122)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
   lt0(z0, Nil) -> False
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
K tuples:none
Defined Rule Symbols:   f[Ite][False][Ite]_3, lt0_2

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c11_2, c12_2


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

(123) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil))) by 
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))

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

(124)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
   lt0(z0, Nil) -> False
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
K tuples:none
Defined Rule Symbols:   f[Ite][False][Ite]_3, lt0_2

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c11_2, c12_2, c11_1


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

(125) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
We considered the (Usable) Rules:none
And the Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(Cons(x_1, x_2)) = 0
   POL(F(x_1, x_2)) = [1]
   POL(False) = 0
   POL(G(x_1, x_2)) = x_1
   POL(G[ITE][FALSE][ITE](x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(LT0(x_1, x_2)) = 0
   POL(Nil) = 0
   POL(True) = 0
   POL(c(x_1)) = x_1
   POL(c11(x_1)) = x_1
   POL(c11(x_1, x_2)) = x_1 + x_2
   POL(c12(x_1, x_2)) = x_1 + x_2
   POL(c6(x_1)) = x_1
   POL(c9(x_1, x_2)) = x_1 + x_2
   POL(f[Ite][False][Ite](x_1, x_2, x_3)) = [1] + x_1
   POL(lt0(x_1, x_2)) = [1] + x_1 + x_2

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

(126)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
   lt0(z0, Nil) -> False
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
K tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
Defined Rule Symbols:   f[Ite][False][Ite]_3, lt0_2

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c11_2, c12_2, c11_1


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

(127) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil))) by 
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))

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

(128)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
   lt0(z0, Nil) -> False
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
K tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
Defined Rule Symbols:   f[Ite][False][Ite]_3, lt0_2

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c11_2, c12_2, c11_1


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

(129) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil))) by 
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(z0, f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))

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

(130)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
   lt0(z0, Nil) -> False
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
K tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
Defined Rule Symbols:   f[Ite][False][Ite]_3, lt0_2

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c11_2, c12_2, c11_1


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

(131) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil))) by 
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))

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

(132)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
   lt0(z0, Nil) -> False
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
K tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
Defined Rule Symbols:   f[Ite][False][Ite]_3, lt0_2

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c12_2, c11_2, c11_1


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

(133) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil))) by 
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))

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

(134)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
   lt0(z0, Nil) -> False
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
K tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
Defined Rule Symbols:   f[Ite][False][Ite]_3, lt0_2

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c12_2, c11_2, c11_1


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

(135) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil))) by 
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))

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

(136)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
   lt0(z0, Nil) -> False
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
K tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
Defined Rule Symbols:   f[Ite][False][Ite]_3, lt0_2

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c12_2, c11_2, c11_1


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

(137) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil))) by 
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))

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

(138)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
   lt0(z0, Nil) -> False
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
K tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
Defined Rule Symbols:   f[Ite][False][Ite]_3, lt0_2

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c12_2, c11_2, c11_1, c12_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.
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
We considered the (Usable) Rules:none
And the Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(Cons(x_1, x_2)) = 0
   POL(F(x_1, x_2)) = [1]
   POL(False) = [1]
   POL(G(x_1, x_2)) = x_1
   POL(G[ITE][FALSE][ITE](x_1, x_2, x_3)) = x_2 + x_3
   POL(LT0(x_1, x_2)) = 0
   POL(Nil) = 0
   POL(True) = 0
   POL(c(x_1)) = x_1
   POL(c11(x_1)) = x_1
   POL(c11(x_1, x_2)) = x_1 + x_2
   POL(c12(x_1)) = x_1
   POL(c12(x_1, x_2)) = x_1 + x_2
   POL(c6(x_1)) = x_1
   POL(c9(x_1, x_2)) = x_1 + x_2
   POL(f[Ite][False][Ite](x_1, x_2, x_3)) = [1] + x_1 + x_2 + x_3
   POL(lt0(x_1, x_2)) = [1] + x_1 + x_2

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

(140)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
   lt0(z0, Nil) -> False
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
K tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
Defined Rule Symbols:   f[Ite][False][Ite]_3, lt0_2

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c12_2, c11_2, c11_1, c12_1


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

(141) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil))) by 
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))

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

(142)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
   lt0(z0, Nil) -> False
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
K tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
Defined Rule Symbols:   f[Ite][False][Ite]_3, lt0_2

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c12_2, c11_2, c11_1, c12_1


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

(143) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](lt0(z1, Nil), Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil))) by 
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(z0, f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))

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

(144)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
   lt0(z0, Nil) -> False
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
K tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
Defined Rule Symbols:   f[Ite][False][Ite]_3, lt0_2

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c12_2, c11_2, c11_1, c12_1


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

(145) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](lt0(x1, Nil), Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil))) by 
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))

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

(146)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
   f[Ite][False][Ite](True, z0, z1) -> z0
   lt0(z0, Nil) -> False
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
K tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
Defined Rule Symbols:   f[Ite][False][Ite]_3, lt0_2

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c11_2, c11_1, c12_2, c12_1


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

(147) CdtUsableRulesProof (BOTH BOUNDS(ID, ID))
The following rules are not usable and were removed:
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2
   f[Ite][False][Ite](True, z0, z1) -> z0
   lt0(z0, Nil) -> False

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

(148)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
K tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
Defined Rule Symbols:   f[Ite][False][Ite]_3

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c11_2, c11_1, c12_2, c12_1


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

(149) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil))) by 
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))

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

(150)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
K tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
Defined Rule Symbols:   f[Ite][False][Ite]_3

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c11_2, c11_1, c12_2, c12_1


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

(151) CdtKnowledgeProof (BOTH BOUNDS(ID, ID))
The following tuples could be moved from S to K by knowledge propagation:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))

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

(152)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
K tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
Defined Rule Symbols:   f[Ite][False][Ite]_3

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c11_2, c11_1, c12_2, c12_1


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

(153) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace F(Cons(x0, z0), Cons(x2, x3)) -> c11(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil))) by 
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))

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

(154)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
K tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
Defined Rule Symbols:   f[Ite][False][Ite]_3

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c11_2, c11_1, c12_2, c12_1


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

(155) CdtKnowledgeProof (BOTH BOUNDS(ID, ID))
The following tuples could be moved from S to K by knowledge propagation:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))

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

(156)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
K tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
Defined Rule Symbols:   f[Ite][False][Ite]_3

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c11_2, c11_1, c12_2, c12_1


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

(157) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil))) by 
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))

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

(158)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
K tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
Defined Rule Symbols:   f[Ite][False][Ite]_3

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c11_2, c11_1, c12_2, c12_1


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

(159) CdtKnowledgeProof (BOTH BOUNDS(ID, ID))
The following tuples could be moved from S to K by knowledge propagation:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))

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

(160)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
K tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
Defined Rule Symbols:   f[Ite][False][Ite]_3

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c11_2, c11_1, c12_2, c12_1


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

(161) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil))) by 
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))

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

(162)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
K tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
Defined Rule Symbols:   f[Ite][False][Ite]_3

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c11_1, c12_2, c12_1, c11_2


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

(163) CdtKnowledgeProof (BOTH BOUNDS(ID, ID))
The following tuples could be moved from S to K by knowledge propagation:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))

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

(164)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
K tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
Defined Rule Symbols:   f[Ite][False][Ite]_3

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c11_1, c12_2, c12_1, c11_2


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

(165) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), z0), LT0(Cons(x0, z0), Cons(Nil, Nil))) by 
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))

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

(166)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
K tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
Defined Rule Symbols:   f[Ite][False][Ite]_3

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c11_1, c12_2, c12_1, c11_2


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

(167) CdtKnowledgeProof (BOTH BOUNDS(ID, ID))
The following tuples could be moved from S to K by knowledge propagation:
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))

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

(168)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
K tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
Defined Rule Symbols:   f[Ite][False][Ite]_3

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c11_1, c12_2, c12_1, c11_2


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

(169) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace F(Cons(x0, z0), Cons(x2, x3)) -> c12(F(f[Ite][False][Ite](False, Cons(x0, z0), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, z0), Cons(Nil, Nil))) by 
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))

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

(170)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
K tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
Defined Rule Symbols:   f[Ite][False][Ite]_3

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c11_1, c12_2, c12_1, c11_2


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

(171) CdtKnowledgeProof (BOTH BOUNDS(ID, ID))
The following tuples could be moved from S to K by knowledge propagation:
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))

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

(172)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
K tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
Defined Rule Symbols:   f[Ite][False][Ite]_3

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c11_1, c12_2, c12_1, c11_2


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

(173) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, f[Ite][False][Ite](False, Cons(z0, z1), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil))) by 
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))

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

(174)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
K tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
Defined Rule Symbols:   f[Ite][False][Ite]_3

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c11_1, c12_2, c12_1, c11_2


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

(175) CdtKnowledgeProof (BOTH BOUNDS(ID, ID))
The following tuples could be moved from S to K by knowledge propagation:
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))

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

(176)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
K tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
Defined Rule Symbols:   f[Ite][False][Ite]_3

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c11_1, c12_2, c12_1, c11_2


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

(177) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), f[Ite][False][Ite](False, Cons(x0, x1), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil))) by 
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))

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

(178)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
K tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
Defined Rule Symbols:   f[Ite][False][Ite]_3

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c11_1, c12_1, c11_2, c12_2


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

(179) CdtKnowledgeProof (BOTH BOUNDS(ID, ID))
The following tuples could be moved from S to K by knowledge propagation:
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))

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

(180)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
K tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
Defined Rule Symbols:   f[Ite][False][Ite]_3

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c11_1, c12_1, c11_2, c12_2


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

(181) CdtUsableRulesProof (BOTH BOUNDS(ID, ID))
The following rules are not usable and were removed:
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1)

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

(182)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
K tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
Defined Rule Symbols:none

Defined Pair Symbols:   LT0_2, G[ITE][FALSE][ITE]_3, G_2, F_2

Compound Symbols:   c6_1, c_1, c9_2, c11_1, c12_1, c11_2, c12_2


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

(183) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), z2) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), z2))) by 
   G[ITE][FALSE][ITE](False, Cons(x0, Cons(z1, z2)), Cons(Cons(Nil, Nil), x2)) -> c(G(Cons(z1, z2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2))))

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

(184)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   G[ITE][FALSE][ITE](False, Cons(x0, Cons(z1, z2)), Cons(Cons(Nil, Nil), x2)) -> c(G(Cons(z1, z2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2))))
S tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
K tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
Defined Rule Symbols:none

Defined Pair Symbols:   LT0_2, G_2, F_2, G[ITE][FALSE][ITE]_3

Compound Symbols:   c6_1, c9_2, c11_1, c12_1, c11_2, c12_2, c_1


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

(185) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3)) by 
   LT0(Cons(z0, Cons(y0, y1)), Cons(z2, Cons(y2, y3))) -> c6(LT0(Cons(y0, y1), Cons(y2, y3)))

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

(186)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
Tuples:
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   G[ITE][FALSE][ITE](False, Cons(x0, Cons(z1, z2)), Cons(Cons(Nil, Nil), x2)) -> c(G(Cons(z1, z2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2))))
   LT0(Cons(z0, Cons(y0, y1)), Cons(z2, Cons(y2, y3))) -> c6(LT0(Cons(y0, y1), Cons(y2, y3)))
S tuples:
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   LT0(Cons(z0, Cons(y0, y1)), Cons(z2, Cons(y2, y3))) -> c6(LT0(Cons(y0, y1), Cons(y2, y3)))
K tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
Defined Rule Symbols:none

Defined Pair Symbols:   G_2, F_2, G[ITE][FALSE][ITE]_3, LT0_2

Compound Symbols:   c9_2, c11_1, c12_1, c11_2, c12_2, c_1, c6_1


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

(187) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 2 trailing nodes:
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(LT0(Cons(x0, x1), Cons(Nil, Nil)))

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

(188)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
Tuples:
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)), LT0(Cons(x1, x2), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   G[ITE][FALSE][ITE](False, Cons(x0, Cons(z1, z2)), Cons(Cons(Nil, Nil), x2)) -> c(G(Cons(z1, z2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2))))
   LT0(Cons(z0, Cons(y0, y1)), Cons(z2, Cons(y2, y3))) -> c6(LT0(Cons(y0, y1), Cons(y2, y3)))
S tuples:
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(x0, x1), Cons(Nil, Nil)))
   LT0(Cons(z0, Cons(y0, y1)), Cons(z2, Cons(y2, y3))) -> c6(LT0(Cons(y0, y1), Cons(y2, y3)))
K tuples:none
Defined Rule Symbols:none

Defined Pair Symbols:   G_2, F_2, G[ITE][FALSE][ITE]_3, LT0_2

Compound Symbols:   c9_2, c11_2, c12_2, c_1, c6_1


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

(189) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 9 trailing tuple parts
----------------------------------------

(190)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
Tuples:
   G[ITE][FALSE][ITE](False, Cons(x0, Cons(z1, z2)), Cons(Cons(Nil, Nil), x2)) -> c(G(Cons(z1, z2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2))))
   LT0(Cons(z0, Cons(y0, y1)), Cons(z2, Cons(y2, y3))) -> c6(LT0(Cons(y0, y1), Cons(y2, y3)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
S tuples:
   LT0(Cons(z0, Cons(y0, y1)), Cons(z2, Cons(y2, y3))) -> c6(LT0(Cons(y0, y1), Cons(y2, y3)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
K tuples:none
Defined Rule Symbols:none

Defined Pair Symbols:   G[ITE][FALSE][ITE]_3, LT0_2, G_2, F_2

Compound Symbols:   c_1, c6_1, c9_1, c11_1, c12_1


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

(191) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   LT0(Cons(z0, Cons(y0, y1)), Cons(z2, Cons(y2, y3))) -> c6(LT0(Cons(y0, y1), Cons(y2, y3)))
We considered the (Usable) Rules:none
And the Tuples:
   G[ITE][FALSE][ITE](False, Cons(x0, Cons(z1, z2)), Cons(Cons(Nil, Nil), x2)) -> c(G(Cons(z1, z2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2))))
   LT0(Cons(z0, Cons(y0, y1)), Cons(z2, Cons(y2, y3))) -> c6(LT0(Cons(y0, y1), Cons(y2, y3)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(Cons(x_1, x_2)) = [1] + x_2
   POL(F(x_1, x_2)) = 0
   POL(False) = 0
   POL(G(x_1, x_2)) = 0
   POL(G[ITE][FALSE][ITE](x_1, x_2, x_3)) = [3]x_1
   POL(LT0(x_1, x_2)) = [2]x_1
   POL(Nil) = 0
   POL(c(x_1)) = x_1
   POL(c11(x_1)) = x_1
   POL(c12(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c9(x_1)) = x_1

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

(192)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
Tuples:
   G[ITE][FALSE][ITE](False, Cons(x0, Cons(z1, z2)), Cons(Cons(Nil, Nil), x2)) -> c(G(Cons(z1, z2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2))))
   LT0(Cons(z0, Cons(y0, y1)), Cons(z2, Cons(y2, y3))) -> c6(LT0(Cons(y0, y1), Cons(y2, y3)))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
S tuples:
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
K tuples:
   LT0(Cons(z0, Cons(y0, y1)), Cons(z2, Cons(y2, y3))) -> c6(LT0(Cons(y0, y1), Cons(y2, y3)))
Defined Rule Symbols:none

Defined Pair Symbols:   G[ITE][FALSE][ITE]_3, LT0_2, G_2, F_2

Compound Symbols:   c_1, c6_1, c9_1, c11_1, c12_1


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

(193) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace G(Cons(x1, x2), Cons(Cons(Nil, Nil), x3)) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), x3))) by 
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x3))) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x3))))

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

(194)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
Tuples:
   G[ITE][FALSE][ITE](False, Cons(x0, Cons(z1, z2)), Cons(Cons(Nil, Nil), x2)) -> c(G(Cons(z1, z2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2))))
   LT0(Cons(z0, Cons(y0, y1)), Cons(z2, Cons(y2, y3))) -> c6(LT0(Cons(y0, y1), Cons(y2, y3)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x3))) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x3))))
S tuples:
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
K tuples:
   LT0(Cons(z0, Cons(y0, y1)), Cons(z2, Cons(y2, y3))) -> c6(LT0(Cons(y0, y1), Cons(y2, y3)))
Defined Rule Symbols:none

Defined Pair Symbols:   G[ITE][FALSE][ITE]_3, LT0_2, F_2, G_2

Compound Symbols:   c_1, c6_1, c11_1, c12_1, c9_1


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

(195) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace G[ITE][FALSE][ITE](False, Cons(x0, Cons(z1, z2)), Cons(Cons(Nil, Nil), x2)) -> c(G(Cons(z1, z2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2)))) by 
   G[ITE][FALSE][ITE](False, Cons(x0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2))) -> c(G(Cons(z1, z2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2)))))

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

(196)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
Tuples:
   LT0(Cons(z0, Cons(y0, y1)), Cons(z2, Cons(y2, y3))) -> c6(LT0(Cons(y0, y1), Cons(y2, y3)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x3))) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x3))))
   G[ITE][FALSE][ITE](False, Cons(x0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2))) -> c(G(Cons(z1, z2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2)))))
S tuples:
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
K tuples:
   LT0(Cons(z0, Cons(y0, y1)), Cons(z2, Cons(y2, y3))) -> c6(LT0(Cons(y0, y1), Cons(y2, y3)))
Defined Rule Symbols:none

Defined Pair Symbols:   LT0_2, F_2, G_2, G[ITE][FALSE][ITE]_3

Compound Symbols:   c6_1, c11_1, c12_1, c9_1, c_1


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

(197) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace G(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x3))) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x3)))) by 
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x3)))))

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

(198)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
Tuples:
   LT0(Cons(z0, Cons(y0, y1)), Cons(z2, Cons(y2, y3))) -> c6(LT0(Cons(y0, y1), Cons(y2, y3)))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   G[ITE][FALSE][ITE](False, Cons(x0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2))) -> c(G(Cons(z1, z2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2)))))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x3)))))
S tuples:
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
K tuples:
   LT0(Cons(z0, Cons(y0, y1)), Cons(z2, Cons(y2, y3))) -> c6(LT0(Cons(y0, y1), Cons(y2, y3)))
Defined Rule Symbols:none

Defined Pair Symbols:   LT0_2, F_2, G[ITE][FALSE][ITE]_3, G_2

Compound Symbols:   c6_1, c11_1, c12_1, c_1, c9_1


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

(199) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace LT0(Cons(z0, Cons(y0, y1)), Cons(z2, Cons(y2, y3))) -> c6(LT0(Cons(y0, y1), Cons(y2, y3))) by 
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))

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

(200)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
Tuples:
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   G[ITE][FALSE][ITE](False, Cons(x0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2))) -> c(G(Cons(z1, z2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2)))))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x3)))))
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
S tuples:
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
K tuples:
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
Defined Rule Symbols:none

Defined Pair Symbols:   F_2, G[ITE][FALSE][ITE]_3, G_2, LT0_2

Compound Symbols:   c11_1, c12_1, c_1, c9_1, c6_1


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

(201) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, z1)) by 
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(y0, y1)))

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

(202)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
Tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   G[ITE][FALSE][ITE](False, Cons(x0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2))) -> c(G(Cons(z1, z2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2)))))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x3)))))
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(y0, y1)))
S tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(y0, y1)))
K tuples:
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
Defined Rule Symbols:none

Defined Pair Symbols:   F_2, G[ITE][FALSE][ITE]_3, G_2, LT0_2

Compound Symbols:   c11_1, c12_1, c_1, c9_1, c6_1


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

(203) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1)) by 
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))

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

(204)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
Tuples:
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   G[ITE][FALSE][ITE](False, Cons(x0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2))) -> c(G(Cons(z1, z2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2)))))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x3)))))
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(y0, y1)))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
S tuples:
   F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(y0, y1)))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
K tuples:
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
Defined Rule Symbols:none

Defined Pair Symbols:   F_2, G[ITE][FALSE][ITE]_3, G_2, LT0_2

Compound Symbols:   c11_1, c12_1, c_1, c9_1, c6_1


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

(205) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace F(Cons(z0, z1), Cons(x2, x3)) -> c11(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3)))) by 
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c11(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))

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

(206)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
Tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   G[ITE][FALSE][ITE](False, Cons(x0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2))) -> c(G(Cons(z1, z2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2)))))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x3)))))
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(y0, y1)))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c11(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
S tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(y0, y1)))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c11(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
K tuples:
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
Defined Rule Symbols:none

Defined Pair Symbols:   F_2, G[ITE][FALSE][ITE]_3, G_2, LT0_2

Compound Symbols:   c11_1, c12_1, c_1, c9_1, c6_1


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

(207) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(y0, y1))) by 
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(z0, Cons(z1, z2))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(z3, z4)) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))

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

(208)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
Tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   G[ITE][FALSE][ITE](False, Cons(x0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2))) -> c(G(Cons(z1, z2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2)))))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x3)))))
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c11(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(z0, Cons(z1, z2))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(z3, z4)) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
S tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c11(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(z0, Cons(z1, z2))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(z3, z4)) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
K tuples:
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
Defined Rule Symbols:none

Defined Pair Symbols:   F_2, G[ITE][FALSE][ITE]_3, G_2, LT0_2

Compound Symbols:   c11_1, c12_1, c_1, c9_1, c6_1


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

(209) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, z1)) by 
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(y0, y1)))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(y0, Cons(y1, y2))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(y0, Cons(y1, Cons(y2, y3)))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(y0, y1))))

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

(210)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
Tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   G[ITE][FALSE][ITE](False, Cons(x0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2))) -> c(G(Cons(z1, z2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2)))))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x3)))))
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c11(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(z0, Cons(z1, z2))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(z3, z4)) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(y0, y1)))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(y0, Cons(y1, y2))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(y0, Cons(y1, Cons(y2, y3)))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(y0, y1))))
S tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c11(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(z0, Cons(z1, z2))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(z3, z4)) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(y0, y1)))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(y0, Cons(y1, y2))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(y0, Cons(y1, Cons(y2, y3)))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(y0, y1))))
K tuples:
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
Defined Rule Symbols:none

Defined Pair Symbols:   F_2, G[ITE][FALSE][ITE]_3, G_2, LT0_2

Compound Symbols:   c11_1, c12_1, c_1, c9_1, c6_1


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

(211) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), x1)) by 
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y4, y5)), Cons(z2, Cons(y2, y3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, y3))), Cons(y4, y5)))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y2, y3))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(y2, y3))))
   F(Cons(z0, Cons(y3, Cons(y4, y5))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y3, Cons(y4, y5))))
   F(Cons(z0, Cons(y5, y6)), Cons(z2, Cons(y2, Cons(y3, y4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, Cons(y3, y4)))), Cons(y5, y6)))
   F(Cons(z0, Cons(y3, y4)), Cons(Cons(Nil, Nil), Cons(y1, y2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(y3, y4)))

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

(212)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
Tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   G[ITE][FALSE][ITE](False, Cons(x0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2))) -> c(G(Cons(z1, z2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2)))))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x3)))))
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c11(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(z0, Cons(z1, z2))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(z3, z4)) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(y0, y1)))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(y0, Cons(y1, y2))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(y0, Cons(y1, Cons(y2, y3)))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(y0, y1))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y4, y5)), Cons(z2, Cons(y2, y3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, y3))), Cons(y4, y5)))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y2, y3))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(y2, y3))))
   F(Cons(z0, Cons(y3, Cons(y4, y5))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y3, Cons(y4, y5))))
   F(Cons(z0, Cons(y5, y6)), Cons(z2, Cons(y2, Cons(y3, y4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, Cons(y3, y4)))), Cons(y5, y6)))
   F(Cons(z0, Cons(y3, y4)), Cons(Cons(Nil, Nil), Cons(y1, y2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(y3, y4)))
S tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c11(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(z0, Cons(z1, z2))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(z3, z4)) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(y0, y1)))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(y0, Cons(y1, y2))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(y0, Cons(y1, Cons(y2, y3)))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(y0, y1))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y4, y5)), Cons(z2, Cons(y2, y3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, y3))), Cons(y4, y5)))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y2, y3))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(y2, y3))))
   F(Cons(z0, Cons(y3, Cons(y4, y5))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y3, Cons(y4, y5))))
   F(Cons(z0, Cons(y5, y6)), Cons(z2, Cons(y2, Cons(y3, y4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, Cons(y3, y4)))), Cons(y5, y6)))
   F(Cons(z0, Cons(y3, y4)), Cons(Cons(Nil, Nil), Cons(y1, y2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(y3, y4)))
K tuples:
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
Defined Rule Symbols:none

Defined Pair Symbols:   F_2, G[ITE][FALSE][ITE]_3, G_2, LT0_2

Compound Symbols:   c11_1, c12_1, c_1, c9_1, c6_1


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

(213) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace F(Cons(z0, z1), Cons(x2, x3)) -> c12(F(z1, Cons(Cons(Nil, Nil), Cons(x2, x3)))) by 
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4))))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4)))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, Cons(y5, y6))) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, Cons(y5, y6)))))

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

(214)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
Tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   G[ITE][FALSE][ITE](False, Cons(x0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2))) -> c(G(Cons(z1, z2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2)))))
   G(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x3)))))
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c11(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(z0, Cons(z1, z2))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(z3, z4)) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(y0, y1)))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(y0, Cons(y1, y2))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(y0, Cons(y1, Cons(y2, y3)))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(y0, y1))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y4, y5)), Cons(z2, Cons(y2, y3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, y3))), Cons(y4, y5)))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y2, y3))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(y2, y3))))
   F(Cons(z0, Cons(y3, Cons(y4, y5))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y3, Cons(y4, y5))))
   F(Cons(z0, Cons(y5, y6)), Cons(z2, Cons(y2, Cons(y3, y4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, Cons(y3, y4)))), Cons(y5, y6)))
   F(Cons(z0, Cons(y3, y4)), Cons(Cons(Nil, Nil), Cons(y1, y2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(y3, y4)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4))))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4)))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, Cons(y5, y6))) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, Cons(y5, y6)))))
S tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c11(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(z0, Cons(z1, z2))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(z3, z4)) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(y0, y1)))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(y0, Cons(y1, y2))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(y0, Cons(y1, Cons(y2, y3)))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(y0, y1))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y4, y5)), Cons(z2, Cons(y2, y3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, y3))), Cons(y4, y5)))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y2, y3))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(y2, y3))))
   F(Cons(z0, Cons(y3, Cons(y4, y5))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y3, Cons(y4, y5))))
   F(Cons(z0, Cons(y5, y6)), Cons(z2, Cons(y2, Cons(y3, y4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, Cons(y3, y4)))), Cons(y5, y6)))
   F(Cons(z0, Cons(y3, y4)), Cons(Cons(Nil, Nil), Cons(y1, y2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(y3, y4)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4))))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4)))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, Cons(y5, y6))) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, Cons(y5, y6)))))
K tuples:
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
Defined Rule Symbols:none

Defined Pair Symbols:   F_2, G[ITE][FALSE][ITE]_3, G_2, LT0_2

Compound Symbols:   c11_1, c12_1, c_1, c9_1, c6_1


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

(215) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace G(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x3))))) by 
   G(Cons(z0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z2)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z2)))))

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

(216)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
Tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   G[ITE][FALSE][ITE](False, Cons(x0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2))) -> c(G(Cons(z1, z2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2)))))
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c11(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(z0, Cons(z1, z2))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(z3, z4)) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(y0, y1)))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(y0, Cons(y1, y2))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(y0, Cons(y1, Cons(y2, y3)))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(y0, y1))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y4, y5)), Cons(z2, Cons(y2, y3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, y3))), Cons(y4, y5)))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y2, y3))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(y2, y3))))
   F(Cons(z0, Cons(y3, Cons(y4, y5))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y3, Cons(y4, y5))))
   F(Cons(z0, Cons(y5, y6)), Cons(z2, Cons(y2, Cons(y3, y4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, Cons(y3, y4)))), Cons(y5, y6)))
   F(Cons(z0, Cons(y3, y4)), Cons(Cons(Nil, Nil), Cons(y1, y2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(y3, y4)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4))))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4)))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, Cons(y5, y6))) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, Cons(y5, y6)))))
   G(Cons(z0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z2)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z2)))))
S tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c11(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(z0, Cons(z1, z2))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(z3, z4)) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(y0, y1)))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(y0, Cons(y1, y2))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(y0, Cons(y1, Cons(y2, y3)))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(y0, y1))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y4, y5)), Cons(z2, Cons(y2, y3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, y3))), Cons(y4, y5)))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y2, y3))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(y2, y3))))
   F(Cons(z0, Cons(y3, Cons(y4, y5))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y3, Cons(y4, y5))))
   F(Cons(z0, Cons(y5, y6)), Cons(z2, Cons(y2, Cons(y3, y4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, Cons(y3, y4)))), Cons(y5, y6)))
   F(Cons(z0, Cons(y3, y4)), Cons(Cons(Nil, Nil), Cons(y1, y2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(y3, y4)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4))))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4)))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, Cons(y5, y6))) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, Cons(y5, y6)))))
K tuples:
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
Defined Rule Symbols:none

Defined Pair Symbols:   F_2, G[ITE][FALSE][ITE]_3, LT0_2, G_2

Compound Symbols:   c11_1, c12_1, c_1, c6_1, c9_1


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

(217) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace G[ITE][FALSE][ITE](False, Cons(x0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2))) -> c(G(Cons(z1, z2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), x2))))) by 
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(z1, Cons(y1, y2))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z3))) -> c(G(Cons(z1, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z3)))))

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

(218)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
Tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c11(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(z0, Cons(z1, z2))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(z3, z4)) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(y0, y1)))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(y0, Cons(y1, y2))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(y0, Cons(y1, Cons(y2, y3)))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(y0, y1))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y4, y5)), Cons(z2, Cons(y2, y3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, y3))), Cons(y4, y5)))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y2, y3))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(y2, y3))))
   F(Cons(z0, Cons(y3, Cons(y4, y5))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y3, Cons(y4, y5))))
   F(Cons(z0, Cons(y5, y6)), Cons(z2, Cons(y2, Cons(y3, y4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, Cons(y3, y4)))), Cons(y5, y6)))
   F(Cons(z0, Cons(y3, y4)), Cons(Cons(Nil, Nil), Cons(y1, y2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(y3, y4)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4))))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4)))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, Cons(y5, y6))) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, Cons(y5, y6)))))
   G(Cons(z0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z2)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z2)))))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(z1, Cons(y1, y2))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z3))) -> c(G(Cons(z1, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z3)))))
S tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c11(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(z0, Cons(z1, z2))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(z3, z4)) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(y0, y1)))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(y0, Cons(y1, y2))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(y0, Cons(y1, Cons(y2, y3)))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(y0, y1))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y4, y5)), Cons(z2, Cons(y2, y3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, y3))), Cons(y4, y5)))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y2, y3))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(y2, y3))))
   F(Cons(z0, Cons(y3, Cons(y4, y5))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y3, Cons(y4, y5))))
   F(Cons(z0, Cons(y5, y6)), Cons(z2, Cons(y2, Cons(y3, y4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, Cons(y3, y4)))), Cons(y5, y6)))
   F(Cons(z0, Cons(y3, y4)), Cons(Cons(Nil, Nil), Cons(y1, y2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(y3, y4)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4))))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4)))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, Cons(y5, y6))) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, Cons(y5, y6)))))
K tuples:
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
Defined Rule Symbols:none

Defined Pair Symbols:   F_2, LT0_2, G_2, G[ITE][FALSE][ITE]_3

Compound Symbols:   c11_1, c12_1, c6_1, c9_1, c_1


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

(219) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace G(Cons(z0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z2)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z2))))) by 
   G(Cons(z0, Cons(z1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, Cons(z1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z3)))))

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

(220)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
Tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c11(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(z0, Cons(z1, z2))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(z3, z4)) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(y0, y1)))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(y0, Cons(y1, y2))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(y0, Cons(y1, Cons(y2, y3)))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(y0, y1))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y4, y5)), Cons(z2, Cons(y2, y3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, y3))), Cons(y4, y5)))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y2, y3))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(y2, y3))))
   F(Cons(z0, Cons(y3, Cons(y4, y5))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y3, Cons(y4, y5))))
   F(Cons(z0, Cons(y5, y6)), Cons(z2, Cons(y2, Cons(y3, y4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, Cons(y3, y4)))), Cons(y5, y6)))
   F(Cons(z0, Cons(y3, y4)), Cons(Cons(Nil, Nil), Cons(y1, y2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(y3, y4)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4))))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4)))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, Cons(y5, y6))) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, Cons(y5, y6)))))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(z1, Cons(y1, y2))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z3))) -> c(G(Cons(z1, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z3)))))
   G(Cons(z0, Cons(z1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, Cons(z1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z3)))))
S tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c11(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(z0, Cons(z1, z2))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(z3, z4)) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(y0, y1)))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(y0, Cons(y1, y2))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(y0, Cons(y1, Cons(y2, y3)))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(y0, y1))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y4, y5)), Cons(z2, Cons(y2, y3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, y3))), Cons(y4, y5)))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y2, y3))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(y2, y3))))
   F(Cons(z0, Cons(y3, Cons(y4, y5))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y3, Cons(y4, y5))))
   F(Cons(z0, Cons(y5, y6)), Cons(z2, Cons(y2, Cons(y3, y4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, Cons(y3, y4)))), Cons(y5, y6)))
   F(Cons(z0, Cons(y3, y4)), Cons(Cons(Nil, Nil), Cons(y1, y2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(y3, y4)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4))))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4)))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, Cons(y5, y6))) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, Cons(y5, y6)))))
K tuples:
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
Defined Rule Symbols:none

Defined Pair Symbols:   F_2, LT0_2, G[ITE][FALSE][ITE]_3, G_2

Compound Symbols:   c11_1, c12_1, c6_1, c_1, c9_1


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

(221) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace G[ITE][FALSE][ITE](False, Cons(z0, Cons(z1, Cons(y1, y2))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z3))) -> c(G(Cons(z1, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z3))))) by 
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(z1, Cons(z2, Cons(y2, y3)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z4))) -> c(G(Cons(z1, Cons(z2, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z4)))))

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

(222)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
Tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c11(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(z0, Cons(z1, z2))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(z3, z4)) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(y0, y1)))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(y0, Cons(y1, y2))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(y0, Cons(y1, Cons(y2, y3)))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(y0, y1))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y4, y5)), Cons(z2, Cons(y2, y3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, y3))), Cons(y4, y5)))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y2, y3))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(y2, y3))))
   F(Cons(z0, Cons(y3, Cons(y4, y5))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y3, Cons(y4, y5))))
   F(Cons(z0, Cons(y5, y6)), Cons(z2, Cons(y2, Cons(y3, y4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, Cons(y3, y4)))), Cons(y5, y6)))
   F(Cons(z0, Cons(y3, y4)), Cons(Cons(Nil, Nil), Cons(y1, y2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(y3, y4)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4))))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4)))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, Cons(y5, y6))) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, Cons(y5, y6)))))
   G(Cons(z0, Cons(z1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, Cons(z1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z3)))))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(z1, Cons(z2, Cons(y2, y3)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z4))) -> c(G(Cons(z1, Cons(z2, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z4)))))
S tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c11(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(z0, Cons(z1, z2))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(z3, z4)) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(y0, y1)))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(y0, Cons(y1, y2))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(y0, Cons(y1, Cons(y2, y3)))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(y0, y1))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y4, y5)), Cons(z2, Cons(y2, y3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, y3))), Cons(y4, y5)))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y2, y3))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(y2, y3))))
   F(Cons(z0, Cons(y3, Cons(y4, y5))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y3, Cons(y4, y5))))
   F(Cons(z0, Cons(y5, y6)), Cons(z2, Cons(y2, Cons(y3, y4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, Cons(y3, y4)))), Cons(y5, y6)))
   F(Cons(z0, Cons(y3, y4)), Cons(Cons(Nil, Nil), Cons(y1, y2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(y3, y4)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4))))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4)))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, Cons(y5, y6))) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, Cons(y5, y6)))))
K tuples:
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
Defined Rule Symbols:none

Defined Pair Symbols:   F_2, LT0_2, G_2, G[ITE][FALSE][ITE]_3

Compound Symbols:   c11_1, c12_1, c6_1, c9_1, c_1


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

(223) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace F(Cons(x0, x1), Cons(x2, x3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3)))) by 
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x0, x1), Cons(x0, x1)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(x0, x1))))
   F(Cons(x1, Cons(x2, x3)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6)))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6))))))

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

(224)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
Tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c11(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(z0, Cons(z1, z2))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(z3, z4)) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(y0, y1)))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(y0, Cons(y1, y2))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(y0, Cons(y1, Cons(y2, y3)))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(y0, y1))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y4, y5)), Cons(z2, Cons(y2, y3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, y3))), Cons(y4, y5)))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y2, y3))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(y2, y3))))
   F(Cons(z0, Cons(y3, Cons(y4, y5))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y3, Cons(y4, y5))))
   F(Cons(z0, Cons(y5, y6)), Cons(z2, Cons(y2, Cons(y3, y4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, Cons(y3, y4)))), Cons(y5, y6)))
   F(Cons(z0, Cons(y3, y4)), Cons(Cons(Nil, Nil), Cons(y1, y2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(y3, y4)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4))))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4)))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, Cons(y5, y6))) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, Cons(y5, y6)))))
   G(Cons(z0, Cons(z1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, Cons(z1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z3)))))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(z1, Cons(z2, Cons(y2, y3)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z4))) -> c(G(Cons(z1, Cons(z2, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z4)))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x0, x1), Cons(x0, x1)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(x0, x1))))
   F(Cons(x1, Cons(x2, x3)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6)))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6))))))
S tuples:
   F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c11(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(z0, Cons(z1, z2))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(z3, z4)) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(y0, y1)))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(y0, Cons(y1, y2))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(y0, Cons(y1, Cons(y2, y3)))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(y0, y1))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y4, y5)), Cons(z2, Cons(y2, y3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, y3))), Cons(y4, y5)))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y2, y3))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(y2, y3))))
   F(Cons(z0, Cons(y3, Cons(y4, y5))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y3, Cons(y4, y5))))
   F(Cons(z0, Cons(y5, y6)), Cons(z2, Cons(y2, Cons(y3, y4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, Cons(y3, y4)))), Cons(y5, y6)))
   F(Cons(z0, Cons(y3, y4)), Cons(Cons(Nil, Nil), Cons(y1, y2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(y3, y4)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4))))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4)))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, Cons(y5, y6))) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, Cons(y5, y6)))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x0, x1), Cons(x0, x1)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(x0, x1))))
   F(Cons(x1, Cons(x2, x3)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6)))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6))))))
K tuples:
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
Defined Rule Symbols:none

Defined Pair Symbols:   F_2, LT0_2, G_2, G[ITE][FALSE][ITE]_3

Compound Symbols:   c12_1, c6_1, c11_1, c9_1, c_1


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

(225) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace F(Cons(x0, x1), Cons(x2, x3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3)))) by 
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x0, x1), Cons(x0, x1)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(x0, x1))))
   F(Cons(x1, Cons(x2, x3)), Cons(x1, Cons(x2, x3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6)))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))))))

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

(226)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
Tuples:
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c11(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(z0, Cons(z1, z2))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(z3, z4)) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(y0, y1)))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(y0, Cons(y1, y2))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(y0, Cons(y1, Cons(y2, y3)))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(y0, y1))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y4, y5)), Cons(z2, Cons(y2, y3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, y3))), Cons(y4, y5)))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y2, y3))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(y2, y3))))
   F(Cons(z0, Cons(y3, Cons(y4, y5))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y3, Cons(y4, y5))))
   F(Cons(z0, Cons(y5, y6)), Cons(z2, Cons(y2, Cons(y3, y4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, Cons(y3, y4)))), Cons(y5, y6)))
   F(Cons(z0, Cons(y3, y4)), Cons(Cons(Nil, Nil), Cons(y1, y2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(y3, y4)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4))))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4)))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, Cons(y5, y6))) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, Cons(y5, y6)))))
   G(Cons(z0, Cons(z1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, Cons(z1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z3)))))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(z1, Cons(z2, Cons(y2, y3)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z4))) -> c(G(Cons(z1, Cons(z2, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z4)))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x0, x1), Cons(x0, x1)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(x0, x1))))
   F(Cons(x1, Cons(x2, x3)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6)))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6))))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x0, x1), Cons(x0, x1)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(x0, x1))))
   F(Cons(x1, Cons(x2, x3)), Cons(x1, Cons(x2, x3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6)))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))))))
S tuples:
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c11(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(z0, Cons(z1, z2))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(z3, z4)) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(y0, y1)))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(y0, Cons(y1, y2))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(y0, Cons(y1, Cons(y2, y3)))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(y0, y1))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y4, y5)), Cons(z2, Cons(y2, y3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, y3))), Cons(y4, y5)))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y2, y3))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(y2, y3))))
   F(Cons(z0, Cons(y3, Cons(y4, y5))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y3, Cons(y4, y5))))
   F(Cons(z0, Cons(y5, y6)), Cons(z2, Cons(y2, Cons(y3, y4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, Cons(y3, y4)))), Cons(y5, y6)))
   F(Cons(z0, Cons(y3, y4)), Cons(Cons(Nil, Nil), Cons(y1, y2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(y3, y4)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4))))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4)))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, Cons(y5, y6))) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, Cons(y5, y6)))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x0, x1), Cons(x0, x1)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(x0, x1))))
   F(Cons(x1, Cons(x2, x3)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6)))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6))))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x0, x1), Cons(x0, x1)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(x0, x1))))
   F(Cons(x1, Cons(x2, x3)), Cons(x1, Cons(x2, x3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6)))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))))))
K tuples:
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
Defined Rule Symbols:none

Defined Pair Symbols:   LT0_2, F_2, G_2, G[ITE][FALSE][ITE]_3

Compound Symbols:   c6_1, c11_1, c12_1, c9_1, c_1


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

(227) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c11(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3))) by 
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(x3, x4)))
   F(Cons(x1, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(z1, z2)))
   F(Cons(x0, Cons(z1, z2)), Cons(x0, Cons(z1, z2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, Cons(z1, z2))), Cons(z1, z2)))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(x2, Cons(x3, x4))))
   F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(x1, x2)))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(x3, Cons(x4, x5))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(x3, x4)))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(x4, x5)))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(x3, Cons(x4, Cons(x5, x6)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x3, x4))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(x2, Cons(x3, x4))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7))), Cons(x2, Cons(x3, Cons(x4, x5)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))), Cons(x2, x3)))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(x0, x1))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(x0, Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(x0, Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))

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

(228)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
Tuples:
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c11(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(z0, Cons(z1, z2))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(z3, z4)) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(y0, y1)))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(y0, Cons(y1, y2))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(y0, Cons(y1, Cons(y2, y3)))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(y0, y1))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y4, y5)), Cons(z2, Cons(y2, y3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, y3))), Cons(y4, y5)))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y2, y3))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(y2, y3))))
   F(Cons(z0, Cons(y3, Cons(y4, y5))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y3, Cons(y4, y5))))
   F(Cons(z0, Cons(y5, y6)), Cons(z2, Cons(y2, Cons(y3, y4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, Cons(y3, y4)))), Cons(y5, y6)))
   F(Cons(z0, Cons(y3, y4)), Cons(Cons(Nil, Nil), Cons(y1, y2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(y3, y4)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4))))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4)))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, Cons(y5, y6))) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, Cons(y5, y6)))))
   G(Cons(z0, Cons(z1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, Cons(z1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z3)))))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(z1, Cons(z2, Cons(y2, y3)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z4))) -> c(G(Cons(z1, Cons(z2, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z4)))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x0, x1), Cons(x0, x1)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(x0, x1))))
   F(Cons(x1, Cons(x2, x3)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6)))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6))))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x0, x1), Cons(x0, x1)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(x0, x1))))
   F(Cons(x1, Cons(x2, x3)), Cons(x1, Cons(x2, x3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6)))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(x3, x4)))
   F(Cons(x1, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(z1, z2)))
   F(Cons(x0, Cons(z1, z2)), Cons(x0, Cons(z1, z2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, Cons(z1, z2))), Cons(z1, z2)))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(x2, Cons(x3, x4))))
   F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(x1, x2)))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(x3, Cons(x4, x5))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(x3, x4)))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(x4, x5)))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(x3, Cons(x4, Cons(x5, x6)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x3, x4))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(x2, Cons(x3, x4))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7))), Cons(x2, Cons(x3, Cons(x4, x5)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))), Cons(x2, x3)))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(x0, x1))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(x0, Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(x0, Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))
S tuples:
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c11(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(z0, Cons(z1, z2))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(z3, z4)) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(y0, y1)))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(y0, Cons(y1, y2))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(y0, Cons(y1, Cons(y2, y3)))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(y0, y1))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y4, y5)), Cons(z2, Cons(y2, y3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, y3))), Cons(y4, y5)))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y2, y3))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(y2, y3))))
   F(Cons(z0, Cons(y3, Cons(y4, y5))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y3, Cons(y4, y5))))
   F(Cons(z0, Cons(y5, y6)), Cons(z2, Cons(y2, Cons(y3, y4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, Cons(y3, y4)))), Cons(y5, y6)))
   F(Cons(z0, Cons(y3, y4)), Cons(Cons(Nil, Nil), Cons(y1, y2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(y3, y4)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4))))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4)))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, Cons(y5, y6))) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, Cons(y5, y6)))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x0, x1), Cons(x0, x1)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(x0, x1))))
   F(Cons(x1, Cons(x2, x3)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6)))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6))))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x0, x1), Cons(x0, x1)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(x0, x1))))
   F(Cons(x1, Cons(x2, x3)), Cons(x1, Cons(x2, x3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6)))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(x3, x4)))
   F(Cons(x1, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(z1, z2)))
   F(Cons(x0, Cons(z1, z2)), Cons(x0, Cons(z1, z2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, Cons(z1, z2))), Cons(z1, z2)))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(x2, Cons(x3, x4))))
   F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(x1, x2)))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(x3, Cons(x4, x5))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(x3, x4)))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(x4, x5)))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(x3, Cons(x4, Cons(x5, x6)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x3, x4))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(x2, Cons(x3, x4))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7))), Cons(x2, Cons(x3, Cons(x4, x5)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))), Cons(x2, x3)))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(x0, x1))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(x0, Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(x0, Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))
K tuples:
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
Defined Rule Symbols:none

Defined Pair Symbols:   LT0_2, F_2, G_2, G[ITE][FALSE][ITE]_3

Compound Symbols:   c6_1, c11_1, c12_1, c9_1, c_1


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

(229) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c11(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3)))) by 
   F(Cons(x1, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c11(F(Cons(z1, z2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))))
   F(Cons(x0, Cons(z1, z2)), Cons(x0, Cons(z1, z2))) -> c11(F(Cons(z1, z2), Cons(Cons(Nil, Nil), Cons(x0, Cons(z1, z2)))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c11(F(Cons(x2, Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c11(F(Cons(x3, x4), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c11(F(Cons(x3, Cons(x4, x5)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(x3, x4), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(x4, x5), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c11(F(Cons(x3, Cons(x4, Cons(x5, x6))), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c11(F(Cons(x2, Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6)))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c11(F(Cons(x2, Cons(x3, Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c11(F(Cons(x2, x3), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))) -> c11(F(Cons(x0, Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))) -> c11(F(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(x1, x2)) -> c11(F(Cons(x0, Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(x0, x1)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(x0, x1))))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x0, Cons(x1, Cons(x2, x3)))) -> c11(F(Cons(x4, x5), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x5, x6)), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(x0, x1))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(x0, Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(x0, Cons(x1, Cons(x2, x3)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))))

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

(230)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
Tuples:
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c11(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(z0, Cons(z1, z2))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(z3, z4)) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(y0, y1)))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(y0, Cons(y1, y2))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(y0, Cons(y1, Cons(y2, y3)))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(y0, y1))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y4, y5)), Cons(z2, Cons(y2, y3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, y3))), Cons(y4, y5)))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y2, y3))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(y2, y3))))
   F(Cons(z0, Cons(y3, Cons(y4, y5))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y3, Cons(y4, y5))))
   F(Cons(z0, Cons(y5, y6)), Cons(z2, Cons(y2, Cons(y3, y4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, Cons(y3, y4)))), Cons(y5, y6)))
   F(Cons(z0, Cons(y3, y4)), Cons(Cons(Nil, Nil), Cons(y1, y2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(y3, y4)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4))))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4)))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, Cons(y5, y6))) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, Cons(y5, y6)))))
   G(Cons(z0, Cons(z1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, Cons(z1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z3)))))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(z1, Cons(z2, Cons(y2, y3)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z4))) -> c(G(Cons(z1, Cons(z2, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z4)))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x0, x1), Cons(x0, x1)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(x0, x1))))
   F(Cons(x1, Cons(x2, x3)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6)))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6))))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x0, x1), Cons(x0, x1)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(x0, x1))))
   F(Cons(x1, Cons(x2, x3)), Cons(x1, Cons(x2, x3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6)))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(x3, x4)))
   F(Cons(x1, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(z1, z2)))
   F(Cons(x0, Cons(z1, z2)), Cons(x0, Cons(z1, z2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, Cons(z1, z2))), Cons(z1, z2)))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(x2, Cons(x3, x4))))
   F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(x1, x2)))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(x3, Cons(x4, x5))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(x3, x4)))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(x4, x5)))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(x3, Cons(x4, Cons(x5, x6)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x3, x4))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(x2, Cons(x3, x4))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7))), Cons(x2, Cons(x3, Cons(x4, x5)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))), Cons(x2, x3)))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(x0, x1))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(x0, Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(x0, Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))
   F(Cons(x1, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c11(F(Cons(z1, z2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))))
   F(Cons(x0, Cons(z1, z2)), Cons(x0, Cons(z1, z2))) -> c11(F(Cons(z1, z2), Cons(Cons(Nil, Nil), Cons(x0, Cons(z1, z2)))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c11(F(Cons(x2, Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c11(F(Cons(x3, x4), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c11(F(Cons(x3, Cons(x4, x5)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(x3, x4), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(x4, x5), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c11(F(Cons(x3, Cons(x4, Cons(x5, x6))), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c11(F(Cons(x2, Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6)))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c11(F(Cons(x2, Cons(x3, Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c11(F(Cons(x2, x3), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))) -> c11(F(Cons(x0, Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))) -> c11(F(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(x1, x2)) -> c11(F(Cons(x0, Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(x0, x1)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(x0, x1))))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x0, Cons(x1, Cons(x2, x3)))) -> c11(F(Cons(x4, x5), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x5, x6)), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(x0, x1))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(x0, Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(x0, Cons(x1, Cons(x2, x3)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))))
S tuples:
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c11(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(z0, Cons(z1, z2))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(z3, z4)) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(y0, y1)))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(y0, Cons(y1, y2))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(y0, Cons(y1, Cons(y2, y3)))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(y0, y1))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y4, y5)), Cons(z2, Cons(y2, y3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, y3))), Cons(y4, y5)))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y2, y3))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(y2, y3))))
   F(Cons(z0, Cons(y3, Cons(y4, y5))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y3, Cons(y4, y5))))
   F(Cons(z0, Cons(y5, y6)), Cons(z2, Cons(y2, Cons(y3, y4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, Cons(y3, y4)))), Cons(y5, y6)))
   F(Cons(z0, Cons(y3, y4)), Cons(Cons(Nil, Nil), Cons(y1, y2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(y3, y4)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4))))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4)))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, Cons(y5, y6))) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, Cons(y5, y6)))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x0, x1), Cons(x0, x1)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(x0, x1))))
   F(Cons(x1, Cons(x2, x3)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6)))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6))))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x0, x1), Cons(x0, x1)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(x0, x1))))
   F(Cons(x1, Cons(x2, x3)), Cons(x1, Cons(x2, x3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6)))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(x3, x4)))
   F(Cons(x1, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(z1, z2)))
   F(Cons(x0, Cons(z1, z2)), Cons(x0, Cons(z1, z2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, Cons(z1, z2))), Cons(z1, z2)))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(x2, Cons(x3, x4))))
   F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(x1, x2)))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(x3, Cons(x4, x5))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(x3, x4)))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(x4, x5)))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(x3, Cons(x4, Cons(x5, x6)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x3, x4))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(x2, Cons(x3, x4))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7))), Cons(x2, Cons(x3, Cons(x4, x5)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))), Cons(x2, x3)))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(x0, x1))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(x0, Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(x0, Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))
   F(Cons(x1, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c11(F(Cons(z1, z2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))))
   F(Cons(x0, Cons(z1, z2)), Cons(x0, Cons(z1, z2))) -> c11(F(Cons(z1, z2), Cons(Cons(Nil, Nil), Cons(x0, Cons(z1, z2)))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c11(F(Cons(x2, Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c11(F(Cons(x3, x4), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c11(F(Cons(x3, Cons(x4, x5)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(x3, x4), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(x4, x5), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c11(F(Cons(x3, Cons(x4, Cons(x5, x6))), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c11(F(Cons(x2, Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6)))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c11(F(Cons(x2, Cons(x3, Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c11(F(Cons(x2, x3), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))) -> c11(F(Cons(x0, Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))) -> c11(F(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(x1, x2)) -> c11(F(Cons(x0, Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(x0, x1)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(x0, x1))))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x0, Cons(x1, Cons(x2, x3)))) -> c11(F(Cons(x4, x5), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x5, x6)), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(x0, x1))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(x0, Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(x0, Cons(x1, Cons(x2, x3)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))))
K tuples:
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
Defined Rule Symbols:none

Defined Pair Symbols:   LT0_2, F_2, G_2, G[ITE][FALSE][ITE]_3

Compound Symbols:   c6_1, c11_1, c12_1, c9_1, c_1


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

(231) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c11(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3)))) by 
   F(Cons(x1, Cons(x2, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(x2, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x0, Cons(z1, Cons(z2, z3))), Cons(x0, Cons(z1, Cons(z2, z3)))) -> c11(F(Cons(z1, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(x0, Cons(z1, Cons(z2, z3))))))
   F(Cons(Cons(Nil, Nil), Cons(x1, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(z2, z3)))) -> c11(F(Cons(x1, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, Cons(z2, z3))))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(z2, z3))), Cons(x1, x2)) -> c11(F(Cons(x3, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(x3, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(x4, Cons(z2, z3))), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(x4, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c11(F(Cons(x3, Cons(x4, Cons(x5, x6))), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c11(F(Cons(x2, Cons(x3, Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x1, Cons(x2, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c11(F(Cons(x2, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))) -> c11(F(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(x1, x2)) -> c11(F(Cons(x0, Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(x0, x1)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(x0, x1))))
   F(Cons(Cons(Nil, Nil), Cons(x4, Cons(z2, z3))), Cons(x0, Cons(x1, Cons(x2, x3)))) -> c11(F(Cons(x4, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x5, x6)), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(x0, x1))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(x0, Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(x0, Cons(x1, Cons(x2, x3)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))))
   F(Cons(x1, Cons(z1, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))) -> c11(F(Cons(z1, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))))))
   F(Cons(x1, Cons(z1, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(z1, Cons(z2, z3)))))) -> c11(F(Cons(z1, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(z1, Cons(z2, z3))))))))
   F(Cons(x0, Cons(z1, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(z1, Cons(z2, z3)))))) -> c11(F(Cons(z1, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(z1, Cons(z2, z3))))))))
   F(Cons(Cons(Nil, Nil), Cons(x1, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))) -> c11(F(Cons(x1, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))))))
   F(Cons(x1, Cons(z1, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))) -> c11(F(Cons(z1, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(z2, z3)))))) -> c11(F(Cons(x0, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(z2, z3))))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))))) -> c11(F(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))))))
   F(Cons(x0, Cons(x1, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(z2, z3)))) -> c11(F(Cons(x1, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, Cons(z2, z3))))))
   F(Cons(x0, Cons(z1, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(x2, Cons(x3, Cons(x4, x5))))) -> c11(F(Cons(z1, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, Cons(x3, Cons(x4, x5)))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(x2, Cons(x3, x4)))) -> c11(F(Cons(x0, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(x2, Cons(x3, Cons(x4, x5))))) -> c11(F(Cons(x0, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, Cons(x3, Cons(x4, x5)))))))

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

(232)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
Tuples:
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(z0, Cons(z1, z2))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(z3, z4)) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(y0, y1)))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(y0, Cons(y1, y2))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(y0, Cons(y1, Cons(y2, y3)))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(y0, y1))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y4, y5)), Cons(z2, Cons(y2, y3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, y3))), Cons(y4, y5)))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y2, y3))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(y2, y3))))
   F(Cons(z0, Cons(y3, Cons(y4, y5))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y3, Cons(y4, y5))))
   F(Cons(z0, Cons(y5, y6)), Cons(z2, Cons(y2, Cons(y3, y4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, Cons(y3, y4)))), Cons(y5, y6)))
   F(Cons(z0, Cons(y3, y4)), Cons(Cons(Nil, Nil), Cons(y1, y2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(y3, y4)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4))))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4)))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, Cons(y5, y6))) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, Cons(y5, y6)))))
   G(Cons(z0, Cons(z1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, Cons(z1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z3)))))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(z1, Cons(z2, Cons(y2, y3)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z4))) -> c(G(Cons(z1, Cons(z2, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), z4)))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x0, x1), Cons(x0, x1)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(x0, x1))))
   F(Cons(x1, Cons(x2, x3)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6)))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6))))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x0, x1), Cons(x0, x1)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(x0, x1))))
   F(Cons(x1, Cons(x2, x3)), Cons(x1, Cons(x2, x3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6)))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(x3, x4)))
   F(Cons(x1, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(z1, z2)))
   F(Cons(x0, Cons(z1, z2)), Cons(x0, Cons(z1, z2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, Cons(z1, z2))), Cons(z1, z2)))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(x2, Cons(x3, x4))))
   F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(x1, x2)))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(x3, Cons(x4, x5))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(x3, x4)))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(x4, x5)))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(x3, Cons(x4, Cons(x5, x6)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x3, x4))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(x2, Cons(x3, x4))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7))), Cons(x2, Cons(x3, Cons(x4, x5)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))), Cons(x2, x3)))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(x0, x1))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(x0, Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(x0, Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))
   F(Cons(x1, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c11(F(Cons(z1, z2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))))
   F(Cons(x0, Cons(z1, z2)), Cons(x0, Cons(z1, z2))) -> c11(F(Cons(z1, z2), Cons(Cons(Nil, Nil), Cons(x0, Cons(z1, z2)))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c11(F(Cons(x2, Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c11(F(Cons(x3, x4), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c11(F(Cons(x3, Cons(x4, x5)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(x3, x4), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(x4, x5), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c11(F(Cons(x3, Cons(x4, Cons(x5, x6))), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c11(F(Cons(x2, Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6)))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c11(F(Cons(x2, Cons(x3, Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c11(F(Cons(x2, x3), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))) -> c11(F(Cons(x0, Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))) -> c11(F(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(x1, x2)) -> c11(F(Cons(x0, Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(x0, x1)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(x0, x1))))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x0, Cons(x1, Cons(x2, x3)))) -> c11(F(Cons(x4, x5), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x5, x6)), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(x0, x1))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(x0, Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(x0, Cons(x1, Cons(x2, x3)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(x3, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(x4, Cons(z2, z3))), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(x4, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(x1, Cons(x2, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c11(F(Cons(x2, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6))))))
   F(Cons(Cons(Nil, Nil), Cons(x4, Cons(z2, z3))), Cons(x0, Cons(x1, Cons(x2, x3)))) -> c11(F(Cons(x4, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))))
   F(Cons(x1, Cons(z1, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))) -> c11(F(Cons(z1, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))))))
   F(Cons(x1, Cons(z1, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(z1, Cons(z2, z3)))))) -> c11(F(Cons(z1, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(z1, Cons(z2, z3))))))))
   F(Cons(x0, Cons(z1, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(z1, Cons(z2, z3)))))) -> c11(F(Cons(z1, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(z1, Cons(z2, z3))))))))
   F(Cons(Cons(Nil, Nil), Cons(x1, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))) -> c11(F(Cons(x1, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))))))
   F(Cons(x1, Cons(z1, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))) -> c11(F(Cons(z1, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(z2, z3)))))) -> c11(F(Cons(x0, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(z2, z3))))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))))) -> c11(F(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))))))
   F(Cons(x0, Cons(x1, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(z2, z3)))) -> c11(F(Cons(x1, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, Cons(z2, z3))))))
   F(Cons(x0, Cons(z1, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(x2, Cons(x3, Cons(x4, x5))))) -> c11(F(Cons(z1, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, Cons(x3, Cons(x4, x5)))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(x2, Cons(x3, x4)))) -> c11(F(Cons(x0, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(x2, Cons(x3, Cons(x4, x5))))) -> c11(F(Cons(x0, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, Cons(x3, Cons(x4, x5)))))))
S tuples:
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(z0, Cons(z1, z2))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(z3, z4)) -> c11(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(z0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(y0, y1)))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(y0, Cons(y1, y2))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(y0, Cons(y1, Cons(y2, y3)))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(y0, y1))))
   F(Cons(z0, Cons(y2, y3)), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y2, y3)))
   F(Cons(z0, Cons(y4, y5)), Cons(z2, Cons(y2, y3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, y3))), Cons(y4, y5)))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y2, y3))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(y2, y3))))
   F(Cons(z0, Cons(y3, Cons(y4, y5))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, z3)), Cons(y3, Cons(y4, y5))))
   F(Cons(z0, Cons(y5, y6)), Cons(z2, Cons(y2, Cons(y3, y4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(z2, Cons(y2, Cons(y3, y4)))), Cons(y5, y6)))
   F(Cons(z0, Cons(y3, y4)), Cons(Cons(Nil, Nil), Cons(y1, y2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(y3, y4)))
   F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, y3)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(Cons(Nil, Nil), Cons(y0, y1))), Cons(z2, z3)) -> c12(F(Cons(Cons(Nil, Nil), Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4))))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(y1, Cons(y2, Cons(y3, y4)))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2)))), Cons(z2, z3)) -> c12(F(Cons(y0, Cons(Cons(Nil, Nil), Cons(y1, y2))), Cons(Cons(Nil, Nil), Cons(z2, z3))))
   F(Cons(z0, Cons(y0, Cons(y1, y2))), Cons(z2, Cons(y5, y6))) -> c12(F(Cons(y0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(z2, Cons(y5, y6)))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x0, x1), Cons(x0, x1)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(x0, x1))))
   F(Cons(x1, Cons(x2, x3)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6)))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6))))))
   F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x0, x1), Cons(x0, x1)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(x0, x1))))
   F(Cons(x1, Cons(x2, x3)), Cons(x1, Cons(x2, x3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6)))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))) -> c12(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(x3, x4)))
   F(Cons(x1, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(z1, z2)))
   F(Cons(x0, Cons(z1, z2)), Cons(x0, Cons(z1, z2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, Cons(z1, z2))), Cons(z1, z2)))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4)))), Cons(x2, Cons(x3, x4))))
   F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(x1, x2)))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(x3, Cons(x4, x5))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2))), Cons(x3, x4)))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3))), Cons(x4, x5)))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(x3, Cons(x4, Cons(x5, x6)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x3, x4))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(x2, Cons(x3, x4))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7))), Cons(x2, Cons(x3, Cons(x4, x5)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))), Cons(x2, x3)))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(x0, x1))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(x0, Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(x0, Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))
   F(Cons(x1, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c11(F(Cons(z1, z2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))))
   F(Cons(x0, Cons(z1, z2)), Cons(x0, Cons(z1, z2))) -> c11(F(Cons(z1, z2), Cons(Cons(Nil, Nil), Cons(x0, Cons(z1, z2)))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c11(F(Cons(x2, Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(x1, x2), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c11(F(Cons(x3, x4), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c11(F(Cons(x3, Cons(x4, x5)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(x3, x4), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(x4, x5), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c11(F(Cons(x3, Cons(x4, Cons(x5, x6))), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c11(F(Cons(x2, Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6)))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c11(F(Cons(x2, Cons(x3, Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x6, x7)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5)))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c11(F(Cons(x2, x3), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))) -> c11(F(Cons(x0, Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))) -> c11(F(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(x1, x2)) -> c11(F(Cons(x0, Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(x0, x1)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(x0, x1))))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x0, Cons(x1, Cons(x2, x3)))) -> c11(F(Cons(x4, x5), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x5, x6)), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))), Cons(x1, x2)) -> c11(F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(Cons(Nil, Nil), Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(x0, x1))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(x0, Cons(x1, x2))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(x0, Cons(x1, Cons(x2, x3)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c11(F(Cons(x3, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, x2)))))
   F(Cons(Cons(Nil, Nil), Cons(x4, Cons(z2, z3))), Cons(x1, Cons(x2, x3))) -> c11(F(Cons(x4, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))))
   F(Cons(x1, Cons(x2, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c11(F(Cons(x2, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6))))))
   F(Cons(Cons(Nil, Nil), Cons(x4, Cons(z2, z3))), Cons(x0, Cons(x1, Cons(x2, x3)))) -> c11(F(Cons(x4, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))))
   F(Cons(x1, Cons(z1, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))) -> c11(F(Cons(z1, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))))))
   F(Cons(x1, Cons(z1, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(z1, Cons(z2, z3)))))) -> c11(F(Cons(z1, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(z1, Cons(z2, z3))))))))
   F(Cons(x0, Cons(z1, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(z1, Cons(z2, z3)))))) -> c11(F(Cons(z1, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(z1, Cons(z2, z3))))))))
   F(Cons(Cons(Nil, Nil), Cons(x1, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))) -> c11(F(Cons(x1, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))))))
   F(Cons(x1, Cons(z1, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))) -> c11(F(Cons(z1, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(z2, z3)))))) -> c11(F(Cons(x0, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(z2, z3))))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1)))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))))) -> c11(F(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))))))) -> c11(F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))))))
   F(Cons(x0, Cons(x1, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(z2, z3)))) -> c11(F(Cons(x1, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x1, Cons(z2, z3))))))
   F(Cons(x0, Cons(z1, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(x2, Cons(x3, Cons(x4, x5))))) -> c11(F(Cons(z1, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, Cons(x3, Cons(x4, x5)))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(x2, Cons(x3, x4)))) -> c11(F(Cons(x0, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, Cons(x3, x4))))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(z2, z3))), Cons(Cons(Nil, Nil), Cons(x2, Cons(x3, Cons(x4, x5))))) -> c11(F(Cons(x0, Cons(z2, z3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, Cons(x3, Cons(x4, x5)))))))
K tuples:
   LT0(Cons(z0, Cons(z1, Cons(y1, y2))), Cons(z3, Cons(z4, Cons(y4, y5)))) -> c6(LT0(Cons(z1, Cons(y1, y2)), Cons(z4, Cons(y4, y5))))
Defined Rule Symbols:none

Defined Pair Symbols:   LT0_2, F_2, G_2, G[ITE][FALSE][ITE]_3

Compound Symbols:   c6_1, c11_1, c12_1, c9_1, c_1