KILLED
proof of input_jyp2PIQ8Al.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), 215 ms]
(2) CpxRelTRS
(3) RenamingProof [BOTH BOUNDS(ID, ID), 0 ms]
(4) CpxRelTRS
(5) RelTrsToTrsProof [UPPER BOUND(ID), 0 ms]
(6) CpxTRS
(7) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms]
(8) CdtProblem
    (9) CdtToCpxRelTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (10) CpxRelTRS
    (11) RenamingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (12) CpxRelTRS
    (13) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
    (14) typed CpxTrs
    (15) OrderProof [LOWER BOUND(ID), 22 ms]
    (16) typed CpxTrs
    (17) RewriteLemmaProof [LOWER BOUND(ID), 307 ms]
    (18) BEST
        (19) proven lower bound
            (20) LowerBoundPropagationProof [FINISHED, 0 ms]
            (21) BOUNDS(n^1, INF)
        (22) typed CpxTrs
            (23) RewriteLemmaProof [LOWER BOUND(ID), 78 ms]
            (24) typed CpxTrs
(25) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms]
(26) CdtProblem
    (27) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms]
    (28) CdtProblem
    (29) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (30) CdtProblem
    (31) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms]
    (32) CdtProblem
    (33) CdtToCpxRelTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (34) CpxRelTRS
        (35) RelTrsToTrsProof [UPPER BOUND(ID), 0 ms]
        (36) CpxTRS
        (37) RelTrsToWeightedTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
        (38) CpxWeightedTrs
            (39) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
            (40) CpxTypedWeightedTrs
            (41) CompletionProof [UPPER BOUND(ID), 0 ms]
            (42) CpxTypedWeightedCompleteTrs
                (43) NarrowingProof [BOTH BOUNDS(ID, ID), 2 ms]
                (44) CpxTypedWeightedCompleteTrs
                (45) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
                (46) CpxRNTS
                (47) InliningProof [UPPER BOUND(ID), 700 ms]
                (48) CpxRNTS
                (49) SimplificationProof [BOTH BOUNDS(ID, ID), 0 ms]
                (50) CpxRNTS
                (51) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 0 ms]
                (52) CpxRNTS
                (53) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
                (54) CpxRNTS
                (55) IntTrsBoundProof [UPPER BOUND(ID), 191 ms]
                (56) CpxRNTS
                (57) IntTrsBoundProof [UPPER BOUND(ID), 65 ms]
                (58) CpxRNTS
                (59) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
                (60) CpxRNTS
                (61) IntTrsBoundProof [UPPER BOUND(ID), 179 ms]
                (62) CpxRNTS
                (63) IntTrsBoundProof [UPPER BOUND(ID), 84 ms]
                (64) CpxRNTS
                (65) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
                (66) CpxRNTS
                (67) IntTrsBoundProof [UPPER BOUND(ID), 454 ms]
                (68) CpxRNTS
                (69) IntTrsBoundProof [UPPER BOUND(ID), 74 ms]
                (70) CpxRNTS
                (71) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
                (72) CpxRNTS
                (73) IntTrsBoundProof [UPPER BOUND(ID), 3698 ms]
                (74) CpxRNTS
                (75) IntTrsBoundProof [UPPER BOUND(ID), 1274 ms]
                (76) CpxRNTS
            (77) CompletionProof [UPPER BOUND(ID), 0 ms]
            (78) CpxTypedWeightedCompleteTrs
                (79) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
                (80) CpxRNTS
    (81) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 87 ms]
    (82) CdtProblem
        (83) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 32 ms]
        (84) CdtProblem
        (85) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (86) CdtProblem
        (87) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
        (88) CdtProblem
        (89) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (90) CdtProblem
        (91) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (92) CdtProblem
        (93) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (94) CdtProblem
        (95) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms]
        (96) CdtProblem
        (97) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (98) CdtProblem
        (99) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (100) CdtProblem
        (101) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (102) CdtProblem
        (103) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (104) CdtProblem
        (105) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (106) CdtProblem
        (107) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (108) CdtProblem
        (109) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (110) CdtProblem
        (111) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (112) CdtProblem
        (113) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (114) CdtProblem
        (115) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (116) CdtProblem
        (117) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (118) CdtProblem
        (119) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (120) CdtProblem
        (121) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (122) CdtProblem
        (123) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms]
        (124) CdtProblem
        (125) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 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)), 0 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) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (148) CdtProblem
        (149) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (150) CdtProblem
        (151) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (152) CdtProblem
        (153) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 27 ms]
        (154) CdtProblem
        (155) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 1 ms]
        (156) CdtProblem
        (157) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (158) CdtProblem
        (159) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (160) CdtProblem
        (161) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms]
        (162) CdtProblem
        (163) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (164) CdtProblem
        (165) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
        (166) CdtProblem
        (167) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (168) CdtProblem
        (169) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
        (170) CdtProblem
        (171) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (172) CdtProblem
        (173) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
        (174) CdtProblem
        (175) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (176) CdtProblem
        (177) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
        (178) CdtProblem
        (179) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (180) CdtProblem
        (181) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
        (182) CdtProblem
        (183) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (184) CdtProblem
        (185) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
        (186) CdtProblem
        (187) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (188) CdtProblem
        (189) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
        (190) CdtProblem
        (191) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (192) CdtProblem
        (193) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
        (194) CdtProblem
        (195) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms]
        (196) CdtProblem
        (197) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (198) CdtProblem
        (199) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (200) CdtProblem
        (201) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (202) CdtProblem
        (203) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (204) CdtProblem
        (205) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (206) CdtProblem
        (207) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
        (208) CdtProblem
        (209) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
        (210) CdtProblem
        (211) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 8 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) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (226) CdtProblem
        (227) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 3 ms]
        (228) CdtProblem
        (229) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (230) CdtProblem
        (231) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (232) CdtProblem
        (233) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (234) CdtProblem
        (235) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (236) CdtProblem
        (237) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (238) CdtProblem
        (239) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 2 ms]
        (240) CdtProblem
        (241) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 64 ms]
        (242) CdtProblem
        (243) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 161 ms]
        (244) CdtProblem
        (245) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 295 ms]
        (246) CdtProblem
        (247) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 489 ms]
        (248) CdtProblem
(249) RelTrsToWeightedTrsProof [UPPER BOUND(ID), 0 ms]
(250) CpxWeightedTrs
    (251) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
    (252) CpxTypedWeightedTrs
    (253) CompletionProof [UPPER BOUND(ID), 0 ms]
    (254) CpxTypedWeightedCompleteTrs
        (255) NarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (256) CpxTypedWeightedCompleteTrs
        (257) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
        (258) CpxRNTS
        (259) InliningProof [UPPER BOUND(ID), 545 ms]
        (260) CpxRNTS
        (261) SimplificationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (262) CpxRNTS
        (263) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 0 ms]
        (264) CpxRNTS
        (265) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (266) CpxRNTS
        (267) IntTrsBoundProof [UPPER BOUND(ID), 143 ms]
        (268) CpxRNTS
        (269) IntTrsBoundProof [UPPER BOUND(ID), 36 ms]
        (270) CpxRNTS
        (271) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (272) CpxRNTS
        (273) IntTrsBoundProof [UPPER BOUND(ID), 338 ms]
        (274) CpxRNTS
        (275) IntTrsBoundProof [UPPER BOUND(ID), 87 ms]
        (276) CpxRNTS
        (277) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (278) CpxRNTS
        (279) IntTrsBoundProof [UPPER BOUND(ID), 406 ms]
        (280) CpxRNTS
        (281) IntTrsBoundProof [UPPER BOUND(ID), 88 ms]
        (282) CpxRNTS
        (283) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (284) CpxRNTS
        (285) IntTrsBoundProof [UPPER BOUND(ID), 1257 ms]
        (286) CpxRNTS
        (287) IntTrsBoundProof [UPPER BOUND(ID), 615 ms]
        (288) CpxRNTS
        (289) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (290) CpxRNTS
        (291) IntTrsBoundProof [UPPER BOUND(ID), 2981 ms]
        (292) CpxRNTS
        (293) IntTrsBoundProof [UPPER BOUND(ID), 909 ms]
        (294) CpxRNTS
    (295) CompletionProof [UPPER BOUND(ID), 0 ms]
    (296) CpxTypedWeightedCompleteTrs
        (297) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
        (298) CpxRNTS


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

(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) RenamingProof (BOTH BOUNDS(ID, ID))
Renamed function symbols to avoid clashes with predefined symbol.
----------------------------------------

(4)
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
----------------------------------------

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

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

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

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


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

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

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


The TRS R consists of the following rules:

   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))

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

   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
   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))

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

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

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


The TRS R consists of the following rules:

   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))

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

   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
   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))

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

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

(14)
Obligation:
Innermost TRS:
Rules:
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))
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
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))

Types:
LT0 :: Cons:Nil -> Cons:Nil -> c6:c7
Cons :: Cons:Nil -> Cons:Nil -> Cons:Nil
c6 :: c6:c7 -> c6:c7
Nil :: Cons:Nil
c7 :: c6:c7
G :: Cons:Nil -> Cons:Nil -> c8:c9
c8 :: c8:c9
c9 :: c:c1 -> c6:c7 -> c8:c9
G[ITE][FALSE][ITE] :: False:True -> Cons:Nil -> Cons:Nil -> c:c1
lt0 :: Cons:Nil -> Cons:Nil -> False:True
F :: Cons:Nil -> Cons:Nil -> c10:c11:c12
c10 :: c10:c11:c12
c11 :: c10:c11:c12 -> c2:c3:c4:c5 -> c6:c7 -> c10:c11:c12
f[Ite][False][Ite] :: False:True -> Cons:Nil -> Cons:Nil -> Cons:Nil
F[ITE][FALSE][ITE] :: False:True -> Cons:Nil -> Cons:Nil -> c2:c3:c4:c5
c12 :: c10:c11:c12 -> c2:c3:c4:c5 -> c6:c7 -> c10:c11:c12
NUMBER42 :: c13
c13 :: c13
GOAL :: Cons:Nil -> Cons:Nil -> c14:c15
c14 :: c10:c11:c12 -> c14:c15
c15 :: c8:c9 -> c14:c15
False :: False:True
c :: c8:c9 -> c:c1
True :: False:True
c1 :: c8:c9 -> c:c1
c2 :: c2:c3:c4:c5
c3 :: c2:c3:c4:c5
c4 :: c2:c3:c4:c5
c5 :: c2:c3:c4:c5
g[Ite][False][Ite] :: False:True -> Cons:Nil -> Cons:Nil -> Cons:Nil
g :: Cons:Nil -> Cons:Nil -> Cons:Nil
f :: Cons:Nil -> Cons:Nil -> Cons:Nil
number42 :: Cons:Nil
goal :: Cons:Nil -> Cons:Nil -> Cons:Nil
hole_c6:c71_16 :: c6:c7
hole_Cons:Nil2_16 :: Cons:Nil
hole_c8:c93_16 :: c8:c9
hole_c:c14_16 :: c:c1
hole_False:True5_16 :: False:True
hole_c10:c11:c126_16 :: c10:c11:c12
hole_c2:c3:c4:c57_16 :: c2:c3:c4:c5
hole_c138_16 :: c13
hole_c14:c159_16 :: c14:c15
gen_c6:c710_16 :: Nat -> c6:c7
gen_Cons:Nil11_16 :: Nat -> Cons:Nil
gen_c10:c11:c1212_16 :: Nat -> c10:c11:c12

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

(15) OrderProof (LOWER BOUND(ID))
Heuristically decided to analyse the following defined symbols:
LT0, G, lt0, F, g, f

They will be analysed ascendingly in the following order:
LT0 < G
LT0 < F
lt0 < G
lt0 < F
lt0 < g
lt0 < f

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

(16)
Obligation:
Innermost TRS:
Rules:
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))
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
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))

Types:
LT0 :: Cons:Nil -> Cons:Nil -> c6:c7
Cons :: Cons:Nil -> Cons:Nil -> Cons:Nil
c6 :: c6:c7 -> c6:c7
Nil :: Cons:Nil
c7 :: c6:c7
G :: Cons:Nil -> Cons:Nil -> c8:c9
c8 :: c8:c9
c9 :: c:c1 -> c6:c7 -> c8:c9
G[ITE][FALSE][ITE] :: False:True -> Cons:Nil -> Cons:Nil -> c:c1
lt0 :: Cons:Nil -> Cons:Nil -> False:True
F :: Cons:Nil -> Cons:Nil -> c10:c11:c12
c10 :: c10:c11:c12
c11 :: c10:c11:c12 -> c2:c3:c4:c5 -> c6:c7 -> c10:c11:c12
f[Ite][False][Ite] :: False:True -> Cons:Nil -> Cons:Nil -> Cons:Nil
F[ITE][FALSE][ITE] :: False:True -> Cons:Nil -> Cons:Nil -> c2:c3:c4:c5
c12 :: c10:c11:c12 -> c2:c3:c4:c5 -> c6:c7 -> c10:c11:c12
NUMBER42 :: c13
c13 :: c13
GOAL :: Cons:Nil -> Cons:Nil -> c14:c15
c14 :: c10:c11:c12 -> c14:c15
c15 :: c8:c9 -> c14:c15
False :: False:True
c :: c8:c9 -> c:c1
True :: False:True
c1 :: c8:c9 -> c:c1
c2 :: c2:c3:c4:c5
c3 :: c2:c3:c4:c5
c4 :: c2:c3:c4:c5
c5 :: c2:c3:c4:c5
g[Ite][False][Ite] :: False:True -> Cons:Nil -> Cons:Nil -> Cons:Nil
g :: Cons:Nil -> Cons:Nil -> Cons:Nil
f :: Cons:Nil -> Cons:Nil -> Cons:Nil
number42 :: Cons:Nil
goal :: Cons:Nil -> Cons:Nil -> Cons:Nil
hole_c6:c71_16 :: c6:c7
hole_Cons:Nil2_16 :: Cons:Nil
hole_c8:c93_16 :: c8:c9
hole_c:c14_16 :: c:c1
hole_False:True5_16 :: False:True
hole_c10:c11:c126_16 :: c10:c11:c12
hole_c2:c3:c4:c57_16 :: c2:c3:c4:c5
hole_c138_16 :: c13
hole_c14:c159_16 :: c14:c15
gen_c6:c710_16 :: Nat -> c6:c7
gen_Cons:Nil11_16 :: Nat -> Cons:Nil
gen_c10:c11:c1212_16 :: Nat -> c10:c11:c12


Generator Equations:
gen_c6:c710_16(0) <=> c7
gen_c6:c710_16(+(x, 1)) <=> c6(gen_c6:c710_16(x))
gen_Cons:Nil11_16(0) <=> Nil
gen_Cons:Nil11_16(+(x, 1)) <=> Cons(Nil, gen_Cons:Nil11_16(x))
gen_c10:c11:c1212_16(0) <=> c10
gen_c10:c11:c1212_16(+(x, 1)) <=> c11(gen_c10:c11:c1212_16(x), c2, c7)


The following defined symbols remain to be analysed:
LT0, G, lt0, F, g, f

They will be analysed ascendingly in the following order:
LT0 < G
LT0 < F
lt0 < G
lt0 < F
lt0 < g
lt0 < f

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

(17) RewriteLemmaProof (LOWER BOUND(ID))
Proved the following rewrite lemma:
LT0(gen_Cons:Nil11_16(n14_16), gen_Cons:Nil11_16(n14_16)) -> gen_c6:c710_16(n14_16), rt in Omega(1 + n14_16)

Induction Base:
LT0(gen_Cons:Nil11_16(0), gen_Cons:Nil11_16(0)) ->_R^Omega(1)
c7

Induction Step:
LT0(gen_Cons:Nil11_16(+(n14_16, 1)), gen_Cons:Nil11_16(+(n14_16, 1))) ->_R^Omega(1)
c6(LT0(gen_Cons:Nil11_16(n14_16), gen_Cons:Nil11_16(n14_16))) ->_IH
c6(gen_c6:c710_16(c15_16))

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

(18)
Complex Obligation (BEST)

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

(19)
Obligation:
Proved the lower bound n^1 for the following obligation:

Innermost TRS:
Rules:
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))
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
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))

Types:
LT0 :: Cons:Nil -> Cons:Nil -> c6:c7
Cons :: Cons:Nil -> Cons:Nil -> Cons:Nil
c6 :: c6:c7 -> c6:c7
Nil :: Cons:Nil
c7 :: c6:c7
G :: Cons:Nil -> Cons:Nil -> c8:c9
c8 :: c8:c9
c9 :: c:c1 -> c6:c7 -> c8:c9
G[ITE][FALSE][ITE] :: False:True -> Cons:Nil -> Cons:Nil -> c:c1
lt0 :: Cons:Nil -> Cons:Nil -> False:True
F :: Cons:Nil -> Cons:Nil -> c10:c11:c12
c10 :: c10:c11:c12
c11 :: c10:c11:c12 -> c2:c3:c4:c5 -> c6:c7 -> c10:c11:c12
f[Ite][False][Ite] :: False:True -> Cons:Nil -> Cons:Nil -> Cons:Nil
F[ITE][FALSE][ITE] :: False:True -> Cons:Nil -> Cons:Nil -> c2:c3:c4:c5
c12 :: c10:c11:c12 -> c2:c3:c4:c5 -> c6:c7 -> c10:c11:c12
NUMBER42 :: c13
c13 :: c13
GOAL :: Cons:Nil -> Cons:Nil -> c14:c15
c14 :: c10:c11:c12 -> c14:c15
c15 :: c8:c9 -> c14:c15
False :: False:True
c :: c8:c9 -> c:c1
True :: False:True
c1 :: c8:c9 -> c:c1
c2 :: c2:c3:c4:c5
c3 :: c2:c3:c4:c5
c4 :: c2:c3:c4:c5
c5 :: c2:c3:c4:c5
g[Ite][False][Ite] :: False:True -> Cons:Nil -> Cons:Nil -> Cons:Nil
g :: Cons:Nil -> Cons:Nil -> Cons:Nil
f :: Cons:Nil -> Cons:Nil -> Cons:Nil
number42 :: Cons:Nil
goal :: Cons:Nil -> Cons:Nil -> Cons:Nil
hole_c6:c71_16 :: c6:c7
hole_Cons:Nil2_16 :: Cons:Nil
hole_c8:c93_16 :: c8:c9
hole_c:c14_16 :: c:c1
hole_False:True5_16 :: False:True
hole_c10:c11:c126_16 :: c10:c11:c12
hole_c2:c3:c4:c57_16 :: c2:c3:c4:c5
hole_c138_16 :: c13
hole_c14:c159_16 :: c14:c15
gen_c6:c710_16 :: Nat -> c6:c7
gen_Cons:Nil11_16 :: Nat -> Cons:Nil
gen_c10:c11:c1212_16 :: Nat -> c10:c11:c12


Generator Equations:
gen_c6:c710_16(0) <=> c7
gen_c6:c710_16(+(x, 1)) <=> c6(gen_c6:c710_16(x))
gen_Cons:Nil11_16(0) <=> Nil
gen_Cons:Nil11_16(+(x, 1)) <=> Cons(Nil, gen_Cons:Nil11_16(x))
gen_c10:c11:c1212_16(0) <=> c10
gen_c10:c11:c1212_16(+(x, 1)) <=> c11(gen_c10:c11:c1212_16(x), c2, c7)


The following defined symbols remain to be analysed:
LT0, G, lt0, F, g, f

They will be analysed ascendingly in the following order:
LT0 < G
LT0 < F
lt0 < G
lt0 < F
lt0 < g
lt0 < f

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

(20) LowerBoundPropagationProof (FINISHED)
Propagated lower bound.
----------------------------------------

(21)
BOUNDS(n^1, INF)

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

(22)
Obligation:
Innermost TRS:
Rules:
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))
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
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))

Types:
LT0 :: Cons:Nil -> Cons:Nil -> c6:c7
Cons :: Cons:Nil -> Cons:Nil -> Cons:Nil
c6 :: c6:c7 -> c6:c7
Nil :: Cons:Nil
c7 :: c6:c7
G :: Cons:Nil -> Cons:Nil -> c8:c9
c8 :: c8:c9
c9 :: c:c1 -> c6:c7 -> c8:c9
G[ITE][FALSE][ITE] :: False:True -> Cons:Nil -> Cons:Nil -> c:c1
lt0 :: Cons:Nil -> Cons:Nil -> False:True
F :: Cons:Nil -> Cons:Nil -> c10:c11:c12
c10 :: c10:c11:c12
c11 :: c10:c11:c12 -> c2:c3:c4:c5 -> c6:c7 -> c10:c11:c12
f[Ite][False][Ite] :: False:True -> Cons:Nil -> Cons:Nil -> Cons:Nil
F[ITE][FALSE][ITE] :: False:True -> Cons:Nil -> Cons:Nil -> c2:c3:c4:c5
c12 :: c10:c11:c12 -> c2:c3:c4:c5 -> c6:c7 -> c10:c11:c12
NUMBER42 :: c13
c13 :: c13
GOAL :: Cons:Nil -> Cons:Nil -> c14:c15
c14 :: c10:c11:c12 -> c14:c15
c15 :: c8:c9 -> c14:c15
False :: False:True
c :: c8:c9 -> c:c1
True :: False:True
c1 :: c8:c9 -> c:c1
c2 :: c2:c3:c4:c5
c3 :: c2:c3:c4:c5
c4 :: c2:c3:c4:c5
c5 :: c2:c3:c4:c5
g[Ite][False][Ite] :: False:True -> Cons:Nil -> Cons:Nil -> Cons:Nil
g :: Cons:Nil -> Cons:Nil -> Cons:Nil
f :: Cons:Nil -> Cons:Nil -> Cons:Nil
number42 :: Cons:Nil
goal :: Cons:Nil -> Cons:Nil -> Cons:Nil
hole_c6:c71_16 :: c6:c7
hole_Cons:Nil2_16 :: Cons:Nil
hole_c8:c93_16 :: c8:c9
hole_c:c14_16 :: c:c1
hole_False:True5_16 :: False:True
hole_c10:c11:c126_16 :: c10:c11:c12
hole_c2:c3:c4:c57_16 :: c2:c3:c4:c5
hole_c138_16 :: c13
hole_c14:c159_16 :: c14:c15
gen_c6:c710_16 :: Nat -> c6:c7
gen_Cons:Nil11_16 :: Nat -> Cons:Nil
gen_c10:c11:c1212_16 :: Nat -> c10:c11:c12


Lemmas:
LT0(gen_Cons:Nil11_16(n14_16), gen_Cons:Nil11_16(n14_16)) -> gen_c6:c710_16(n14_16), rt in Omega(1 + n14_16)


Generator Equations:
gen_c6:c710_16(0) <=> c7
gen_c6:c710_16(+(x, 1)) <=> c6(gen_c6:c710_16(x))
gen_Cons:Nil11_16(0) <=> Nil
gen_Cons:Nil11_16(+(x, 1)) <=> Cons(Nil, gen_Cons:Nil11_16(x))
gen_c10:c11:c1212_16(0) <=> c10
gen_c10:c11:c1212_16(+(x, 1)) <=> c11(gen_c10:c11:c1212_16(x), c2, c7)


The following defined symbols remain to be analysed:
lt0, G, F, g, f

They will be analysed ascendingly in the following order:
lt0 < G
lt0 < F
lt0 < g
lt0 < f

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

(23) RewriteLemmaProof (LOWER BOUND(ID))
Proved the following rewrite lemma:
lt0(gen_Cons:Nil11_16(n516_16), gen_Cons:Nil11_16(n516_16)) -> False, rt in Omega(0)

Induction Base:
lt0(gen_Cons:Nil11_16(0), gen_Cons:Nil11_16(0)) ->_R^Omega(0)
False

Induction Step:
lt0(gen_Cons:Nil11_16(+(n516_16, 1)), gen_Cons:Nil11_16(+(n516_16, 1))) ->_R^Omega(0)
lt0(gen_Cons:Nil11_16(n516_16), gen_Cons:Nil11_16(n516_16)) ->_IH
False

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

(24)
Obligation:
Innermost TRS:
Rules:
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))
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
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))

Types:
LT0 :: Cons:Nil -> Cons:Nil -> c6:c7
Cons :: Cons:Nil -> Cons:Nil -> Cons:Nil
c6 :: c6:c7 -> c6:c7
Nil :: Cons:Nil
c7 :: c6:c7
G :: Cons:Nil -> Cons:Nil -> c8:c9
c8 :: c8:c9
c9 :: c:c1 -> c6:c7 -> c8:c9
G[ITE][FALSE][ITE] :: False:True -> Cons:Nil -> Cons:Nil -> c:c1
lt0 :: Cons:Nil -> Cons:Nil -> False:True
F :: Cons:Nil -> Cons:Nil -> c10:c11:c12
c10 :: c10:c11:c12
c11 :: c10:c11:c12 -> c2:c3:c4:c5 -> c6:c7 -> c10:c11:c12
f[Ite][False][Ite] :: False:True -> Cons:Nil -> Cons:Nil -> Cons:Nil
F[ITE][FALSE][ITE] :: False:True -> Cons:Nil -> Cons:Nil -> c2:c3:c4:c5
c12 :: c10:c11:c12 -> c2:c3:c4:c5 -> c6:c7 -> c10:c11:c12
NUMBER42 :: c13
c13 :: c13
GOAL :: Cons:Nil -> Cons:Nil -> c14:c15
c14 :: c10:c11:c12 -> c14:c15
c15 :: c8:c9 -> c14:c15
False :: False:True
c :: c8:c9 -> c:c1
True :: False:True
c1 :: c8:c9 -> c:c1
c2 :: c2:c3:c4:c5
c3 :: c2:c3:c4:c5
c4 :: c2:c3:c4:c5
c5 :: c2:c3:c4:c5
g[Ite][False][Ite] :: False:True -> Cons:Nil -> Cons:Nil -> Cons:Nil
g :: Cons:Nil -> Cons:Nil -> Cons:Nil
f :: Cons:Nil -> Cons:Nil -> Cons:Nil
number42 :: Cons:Nil
goal :: Cons:Nil -> Cons:Nil -> Cons:Nil
hole_c6:c71_16 :: c6:c7
hole_Cons:Nil2_16 :: Cons:Nil
hole_c8:c93_16 :: c8:c9
hole_c:c14_16 :: c:c1
hole_False:True5_16 :: False:True
hole_c10:c11:c126_16 :: c10:c11:c12
hole_c2:c3:c4:c57_16 :: c2:c3:c4:c5
hole_c138_16 :: c13
hole_c14:c159_16 :: c14:c15
gen_c6:c710_16 :: Nat -> c6:c7
gen_Cons:Nil11_16 :: Nat -> Cons:Nil
gen_c10:c11:c1212_16 :: Nat -> c10:c11:c12


Lemmas:
LT0(gen_Cons:Nil11_16(n14_16), gen_Cons:Nil11_16(n14_16)) -> gen_c6:c710_16(n14_16), rt in Omega(1 + n14_16)
lt0(gen_Cons:Nil11_16(n516_16), gen_Cons:Nil11_16(n516_16)) -> False, rt in Omega(0)


Generator Equations:
gen_c6:c710_16(0) <=> c7
gen_c6:c710_16(+(x, 1)) <=> c6(gen_c6:c710_16(x))
gen_Cons:Nil11_16(0) <=> Nil
gen_Cons:Nil11_16(+(x, 1)) <=> Cons(Nil, gen_Cons:Nil11_16(x))
gen_c10:c11:c1212_16(0) <=> c10
gen_c10:c11:c1212_16(+(x, 1)) <=> c11(gen_c10:c11:c1212_16(x), c2, c7)


The following defined symbols remain to be analysed:
G, F, g, f
----------------------------------------

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

(26)
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


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

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

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

(28)
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


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

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

(30)
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


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

(31) 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))

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

(32)
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


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

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

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


The TRS R consists of the following rules:

   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 (relative) TRS S consists of the following rules:

   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)) -> 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

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

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

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


The TRS R consists of the following rules:

   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)))
   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)) -> 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

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

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

(38)
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(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3)) [1]
   G(z0, Nil) -> c8 [1]
   G(z0, Cons(z1, z2)) -> c9(G[ITE][FALSE][ITE](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), LT0(z0, Cons(Nil, Nil))) [1]
   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))) [1]
   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))) [1]
   G[ITE][FALSE][ITE](False, Cons(z0, z1), z2) -> c(G(z1, Cons(Cons(Nil, Nil), z2))) [0]
   G[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c1(G(z0, z2)) [0]
   lt0(Cons(z0, z1), Cons(z2, z3)) -> lt0(z1, z3) [0]
   lt0(z0, Nil) -> False [0]
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1 [0]
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2 [0]
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1) [0]
   f[Ite][False][Ite](True, z0, z1) -> z0 [0]

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

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

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

   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3)) [1]
   G(z0, Nil) -> c8 [1]
   G(z0, Cons(z1, z2)) -> c9(G[ITE][FALSE][ITE](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), LT0(z0, Cons(Nil, Nil))) [1]
   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))) [1]
   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))) [1]
   G[ITE][FALSE][ITE](False, Cons(z0, z1), z2) -> c(G(z1, Cons(Cons(Nil, Nil), z2))) [0]
   G[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c1(G(z0, z2)) [0]
   lt0(Cons(z0, z1), Cons(z2, z3)) -> lt0(z1, z3) [0]
   lt0(z0, Nil) -> False [0]
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1 [0]
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2 [0]
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1) [0]
   f[Ite][False][Ite](True, z0, z1) -> z0 [0]

The TRS has the following type information:
LT0 :: Cons:Nil -> Cons:Nil -> c6
Cons :: Cons:Nil -> Cons:Nil -> Cons:Nil
c6 :: c6 -> c6
G :: Cons:Nil -> Cons:Nil -> c8:c9
Nil :: Cons:Nil
c8 :: c8:c9
c9 :: c:c1 -> c6 -> c8:c9
G[ITE][FALSE][ITE] :: False:True -> Cons:Nil -> Cons:Nil -> c:c1
lt0 :: Cons:Nil -> Cons:Nil -> False:True
F :: Cons:Nil -> Cons:Nil -> c11:c12
c11 :: c11:c12 -> c6 -> c11:c12
f[Ite][False][Ite] :: False:True -> Cons:Nil -> Cons:Nil -> Cons:Nil
c12 :: c11:c12 -> c6 -> c11:c12
False :: False:True
c :: c8:c9 -> c:c1
True :: False:True
c1 :: c8:c9 -> c:c1

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

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

   LT0_2
   G_2
   F_2

(c) The following functions are completely defined:

   G[ITE][FALSE][ITE]_3
   lt0_2
   f[Ite][False][Ite]_3

Due to the following rules being added:

   G[ITE][FALSE][ITE](v0, v1, v2) -> const1 [0]
   lt0(v0, v1) -> null_lt0 [0]
   f[Ite][False][Ite](v0, v1, v2) -> Nil [0]

And the following fresh constants:    const1, null_lt0, const, const2

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

(42)
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(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3)) [1]
   G(z0, Nil) -> c8 [1]
   G(z0, Cons(z1, z2)) -> c9(G[ITE][FALSE][ITE](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), LT0(z0, Cons(Nil, Nil))) [1]
   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))) [1]
   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))) [1]
   G[ITE][FALSE][ITE](False, Cons(z0, z1), z2) -> c(G(z1, Cons(Cons(Nil, Nil), z2))) [0]
   G[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c1(G(z0, z2)) [0]
   lt0(Cons(z0, z1), Cons(z2, z3)) -> lt0(z1, z3) [0]
   lt0(z0, Nil) -> False [0]
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1 [0]
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2 [0]
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1) [0]
   f[Ite][False][Ite](True, z0, z1) -> z0 [0]
   G[ITE][FALSE][ITE](v0, v1, v2) -> const1 [0]
   lt0(v0, v1) -> null_lt0 [0]
   f[Ite][False][Ite](v0, v1, v2) -> Nil [0]

The TRS has the following type information:
LT0 :: Cons:Nil -> Cons:Nil -> c6
Cons :: Cons:Nil -> Cons:Nil -> Cons:Nil
c6 :: c6 -> c6
G :: Cons:Nil -> Cons:Nil -> c8:c9
Nil :: Cons:Nil
c8 :: c8:c9
c9 :: c:c1:const1 -> c6 -> c8:c9
G[ITE][FALSE][ITE] :: False:True:null_lt0 -> Cons:Nil -> Cons:Nil -> c:c1:const1
lt0 :: Cons:Nil -> Cons:Nil -> False:True:null_lt0
F :: Cons:Nil -> Cons:Nil -> c11:c12
c11 :: c11:c12 -> c6 -> c11:c12
f[Ite][False][Ite] :: False:True:null_lt0 -> Cons:Nil -> Cons:Nil -> Cons:Nil
c12 :: c11:c12 -> c6 -> c11:c12
False :: False:True:null_lt0
c :: c8:c9 -> c:c1:const1
True :: False:True:null_lt0
c1 :: c8:c9 -> c:c1:const1
const1 :: c:c1:const1
null_lt0 :: False:True:null_lt0
const :: c6
const2 :: c11:c12

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

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

(44)
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(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3)) [1]
   G(z0, Nil) -> c8 [1]
   G(Cons(z0', z1'), Cons(z1, z2)) -> c9(G[ITE][FALSE][ITE](lt0(z1', Nil), Cons(z0', z1'), Cons(z1, z2)), LT0(Cons(z0', z1'), Cons(Nil, Nil))) [1]
   G(z0, Cons(z1, z2)) -> c9(G[ITE][FALSE][ITE](null_lt0, z0, Cons(z1, z2)), LT0(z0, Cons(Nil, Nil))) [1]
   F(Cons(z0'', z1''), Cons(z1, z2)) -> c11(F(f[Ite][False][Ite](lt0(z1'', Nil), Cons(z0'', z1''), Cons(z1, z2)), f[Ite][False][Ite](lt0(z1'', Nil), Cons(z0'', z1''), Cons(z1, z2))), LT0(Cons(z0'', z1''), Cons(Nil, Nil))) [1]
   F(Cons(z0'', z1''), Cons(z1, z2)) -> c11(F(f[Ite][False][Ite](lt0(z1'', Nil), Cons(z0'', z1''), Cons(z1, z2)), f[Ite][False][Ite](null_lt0, Cons(z0'', z1''), Cons(z1, z2))), LT0(Cons(z0'', z1''), Cons(Nil, Nil))) [1]
   F(Cons(z01, z11), Cons(z1, z2)) -> c11(F(f[Ite][False][Ite](null_lt0, Cons(z01, z11), Cons(z1, z2)), f[Ite][False][Ite](lt0(z11, Nil), Cons(z01, z11), Cons(z1, z2))), LT0(Cons(z01, z11), Cons(Nil, Nil))) [1]
   F(z0, Cons(z1, z2)) -> c11(F(f[Ite][False][Ite](null_lt0, z0, Cons(z1, z2)), f[Ite][False][Ite](null_lt0, z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil))) [1]
   F(Cons(z02, z12), Cons(z1, z2)) -> c12(F(f[Ite][False][Ite](lt0(z12, Nil), Cons(z02, z12), Cons(z1, z2)), f[Ite][False][Ite](lt0(z12, Nil), Cons(z02, z12), Cons(z1, z2))), LT0(Cons(z02, z12), Cons(Nil, Nil))) [1]
   F(Cons(z02, z12), Cons(z1, z2)) -> c12(F(f[Ite][False][Ite](lt0(z12, Nil), Cons(z02, z12), Cons(z1, z2)), f[Ite][False][Ite](null_lt0, Cons(z02, z12), Cons(z1, z2))), LT0(Cons(z02, z12), Cons(Nil, Nil))) [1]
   F(Cons(z03, z13), Cons(z1, z2)) -> c12(F(f[Ite][False][Ite](null_lt0, Cons(z03, z13), Cons(z1, z2)), f[Ite][False][Ite](lt0(z13, Nil), Cons(z03, z13), Cons(z1, z2))), LT0(Cons(z03, z13), Cons(Nil, Nil))) [1]
   F(z0, Cons(z1, z2)) -> c12(F(f[Ite][False][Ite](null_lt0, z0, Cons(z1, z2)), f[Ite][False][Ite](null_lt0, z0, Cons(z1, z2))), LT0(z0, Cons(Nil, Nil))) [1]
   G[ITE][FALSE][ITE](False, Cons(z0, z1), z2) -> c(G(z1, Cons(Cons(Nil, Nil), z2))) [0]
   G[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c1(G(z0, z2)) [0]
   lt0(Cons(z0, z1), Cons(z2, z3)) -> lt0(z1, z3) [0]
   lt0(z0, Nil) -> False [0]
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1 [0]
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2 [0]
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1) [0]
   f[Ite][False][Ite](True, z0, z1) -> z0 [0]
   G[ITE][FALSE][ITE](v0, v1, v2) -> const1 [0]
   lt0(v0, v1) -> null_lt0 [0]
   f[Ite][False][Ite](v0, v1, v2) -> Nil [0]

The TRS has the following type information:
LT0 :: Cons:Nil -> Cons:Nil -> c6
Cons :: Cons:Nil -> Cons:Nil -> Cons:Nil
c6 :: c6 -> c6
G :: Cons:Nil -> Cons:Nil -> c8:c9
Nil :: Cons:Nil
c8 :: c8:c9
c9 :: c:c1:const1 -> c6 -> c8:c9
G[ITE][FALSE][ITE] :: False:True:null_lt0 -> Cons:Nil -> Cons:Nil -> c:c1:const1
lt0 :: Cons:Nil -> Cons:Nil -> False:True:null_lt0
F :: Cons:Nil -> Cons:Nil -> c11:c12
c11 :: c11:c12 -> c6 -> c11:c12
f[Ite][False][Ite] :: False:True:null_lt0 -> Cons:Nil -> Cons:Nil -> Cons:Nil
c12 :: c11:c12 -> c6 -> c11:c12
False :: False:True:null_lt0
c :: c8:c9 -> c:c1:const1
True :: False:True:null_lt0
c1 :: c8:c9 -> c:c1:const1
const1 :: c:c1:const1
null_lt0 :: False:True:null_lt0
const :: c6
const2 :: c11:c12

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

(45) 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
   c8 => 0
   False => 1
   True => 2
   const1 => 0
   null_lt0 => 0
   const => 0
   const2 => 0

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

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

   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](lt0(z1'', 0), 1 + z0'' + z1'', 1 + z1 + z2), f[Ite][False][Ite](lt0(z1'', 0), 1 + z0'' + z1'', 1 + z1 + z2)) + LT0(1 + z0'' + z1'', 1 + 0 + 0) :|: z = 1 + z0'' + z1'', z1 >= 0, z' = 1 + z1 + z2, z0'' >= 0, z2 >= 0, z1'' >= 0
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](lt0(z1'', 0), 1 + z0'' + z1'', 1 + z1 + z2), f[Ite][False][Ite](0, 1 + z0'' + z1'', 1 + z1 + z2)) + LT0(1 + z0'' + z1'', 1 + 0 + 0) :|: z = 1 + z0'' + z1'', z1 >= 0, z' = 1 + z1 + z2, z0'' >= 0, z2 >= 0, z1'' >= 0
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](lt0(z12, 0), 1 + z02 + z12, 1 + z1 + z2), f[Ite][False][Ite](lt0(z12, 0), 1 + z02 + z12, 1 + z1 + z2)) + LT0(1 + z02 + z12, 1 + 0 + 0) :|: z = 1 + z02 + z12, z1 >= 0, z' = 1 + z1 + z2, z02 >= 0, z12 >= 0, z2 >= 0
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](lt0(z12, 0), 1 + z02 + z12, 1 + z1 + z2), f[Ite][False][Ite](0, 1 + z02 + z12, 1 + z1 + z2)) + LT0(1 + z02 + z12, 1 + 0 + 0) :|: z = 1 + z02 + z12, z1 >= 0, z' = 1 + z1 + z2, z02 >= 0, z12 >= 0, z2 >= 0
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](0, z0, 1 + z1 + z2), f[Ite][False][Ite](0, z0, 1 + z1 + z2)) + LT0(z0, 1 + 0 + 0) :|: z = z0, z1 >= 0, z' = 1 + z1 + z2, z0 >= 0, z2 >= 0
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](0, 1 + z01 + z11, 1 + z1 + z2), f[Ite][False][Ite](lt0(z11, 0), 1 + z01 + z11, 1 + z1 + z2)) + LT0(1 + z01 + z11, 1 + 0 + 0) :|: z11 >= 0, z1 >= 0, z01 >= 0, z = 1 + z01 + z11, z' = 1 + z1 + z2, z2 >= 0
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](0, 1 + z03 + z13, 1 + z1 + z2), f[Ite][False][Ite](lt0(z13, 0), 1 + z03 + z13, 1 + z1 + z2)) + LT0(1 + z03 + z13, 1 + 0 + 0) :|: z = 1 + z03 + z13, z1 >= 0, z' = 1 + z1 + z2, z03 >= 0, z13 >= 0, z2 >= 0
   G(z, z') -{ 1 }-> 0 :|: z = z0, z0 >= 0, z' = 0
   G(z, z') -{ 1 }-> 1 + G[ITE][FALSE][ITE](lt0(z1', 0), 1 + z0' + z1', 1 + z1 + z2) + LT0(1 + z0' + z1', 1 + 0 + 0) :|: z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0
   G(z, z') -{ 1 }-> 1 + G[ITE][FALSE][ITE](0, z0, 1 + z1 + z2) + LT0(z0, 1 + 0 + 0) :|: z = z0, z1 >= 0, z' = 1 + z1 + z2, z0 >= 0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z0, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z0 >= 0, z' = z0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z1, 1 + (1 + 0 + 0) + z2) :|: z'' = z2, z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z2 >= 0
   LT0(z, z') -{ 1 }-> 1 + LT0(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z0 :|: z = 2, z1 >= 0, z0 >= 0, z' = z0, z'' = z1
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z1 :|: z'' = z2, z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z2 >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z2 :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z0 >= 0, z' = z0, z2 >= 0
   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) + z1 :|: z1 >= 0, z = 1, z0 >= 0, z' = z0, z'' = z1
   lt0(z, z') -{ 0 }-> lt0(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   lt0(z, z') -{ 0 }-> 1 :|: z = z0, z0 >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1


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

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

   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z2 :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z0 >= 0, z' = z0, z2 >= 0
   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) + z1 :|: z1 >= 0, z = 1, z0 >= 0, z' = z0, z'' = z1
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z1 :|: z'' = z2, z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z2 >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z0 :|: z = 2, z1 >= 0, z0 >= 0, z' = z0, z'' = z1

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

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

   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](lt0(z1'', 0), 1 + z0'' + z1'', 1 + z1 + z2), f[Ite][False][Ite](lt0(z1'', 0), 1 + z0'' + z1'', 1 + z1 + z2)) + LT0(1 + z0'' + z1'', 1 + 0 + 0) :|: z = 1 + z0'' + z1'', z1 >= 0, z' = 1 + z1 + z2, z0'' >= 0, z2 >= 0, z1'' >= 0
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](lt0(z1'', 0), 1 + z0'' + z1'', 1 + z1 + z2), 0) + LT0(1 + z0'' + z1'', 1 + 0 + 0) :|: z = 1 + z0'' + z1'', z1 >= 0, z' = 1 + z1 + z2, z0'' >= 0, z2 >= 0, z1'' >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z0'' + z1'' = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](lt0(z12, 0), 1 + z02 + z12, 1 + z1 + z2), f[Ite][False][Ite](lt0(z12, 0), 1 + z02 + z12, 1 + z1 + z2)) + LT0(1 + z02 + z12, 1 + 0 + 0) :|: z = 1 + z02 + z12, z1 >= 0, z' = 1 + z1 + z2, z02 >= 0, z12 >= 0, z2 >= 0
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](lt0(z12, 0), 1 + z02 + z12, 1 + z1 + z2), 0) + LT0(1 + z02 + z12, 1 + 0 + 0) :|: z = 1 + z02 + z12, z1 >= 0, z' = 1 + z1 + z2, z02 >= 0, z12 >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z02 + z12 = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(0, f[Ite][False][Ite](lt0(z11, 0), 1 + z01 + z11, 1 + z1 + z2)) + LT0(1 + z01 + z11, 1 + 0 + 0) :|: z11 >= 0, z1 >= 0, z01 >= 0, z = 1 + z01 + z11, z' = 1 + z1 + z2, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z01 + z11 = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(0, f[Ite][False][Ite](lt0(z13, 0), 1 + z03 + z13, 1 + z1 + z2)) + LT0(1 + z03 + z13, 1 + 0 + 0) :|: z = 1 + z03 + z13, z1 >= 0, z' = 1 + z1 + z2, z03 >= 0, z13 >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z03 + z13 = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(0, 0) + LT0(z0, 1 + 0 + 0) :|: z = z0, z1 >= 0, z' = 1 + z1 + z2, z0 >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, z0 = v1, v2 >= 0, v0' >= 0, 1 + z1 + z2 = v2', v1' >= 0, 0 = v0', z0 = v1', v2' >= 0
   G(z, z') -{ 1 }-> 0 :|: z = z0, z0 >= 0, z' = 0
   G(z, z') -{ 1 }-> 1 + G[ITE][FALSE][ITE](lt0(z1', 0), 1 + z0' + z1', 1 + z1 + z2) + LT0(1 + z0' + z1', 1 + 0 + 0) :|: z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0
   G(z, z') -{ 1 }-> 1 + G[ITE][FALSE][ITE](0, z0, 1 + z1 + z2) + LT0(z0, 1 + 0 + 0) :|: z = z0, z1 >= 0, z' = 1 + z1 + z2, z0 >= 0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z0, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z0 >= 0, z' = z0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z1, 1 + (1 + 0 + 0) + z2) :|: z'' = z2, z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z2 >= 0
   LT0(z, z') -{ 1 }-> 1 + LT0(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z0 :|: z = 2, z1 >= 0, z0 >= 0, z' = z0, z'' = z1
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z1 :|: z'' = z2, z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z2 >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z2 :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z0 >= 0, z' = z0, z2 >= 0
   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) + z1 :|: z1 >= 0, z = 1, z0 >= 0, z' = z0, z'' = z1
   lt0(z, z') -{ 0 }-> lt0(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   lt0(z, z') -{ 0 }-> 1 :|: z = z0, z0 >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1


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

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

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

   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](lt0(z1'', 0), 1 + z0'' + z1'', 1 + z1 + z2), f[Ite][False][Ite](lt0(z1'', 0), 1 + z0'' + z1'', 1 + z1 + z2)) + LT0(1 + z0'' + z1'', 1 + 0 + 0) :|: z = 1 + z0'' + z1'', z1 >= 0, z' = 1 + z1 + z2, z0'' >= 0, z2 >= 0, z1'' >= 0
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](lt0(z1'', 0), 1 + z0'' + z1'', 1 + z1 + z2), 0) + LT0(1 + z0'' + z1'', 1 + 0 + 0) :|: z = 1 + z0'' + z1'', z1 >= 0, z' = 1 + z1 + z2, z0'' >= 0, z2 >= 0, z1'' >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z0'' + z1'' = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](lt0(z12, 0), 1 + z02 + z12, 1 + z1 + z2), f[Ite][False][Ite](lt0(z12, 0), 1 + z02 + z12, 1 + z1 + z2)) + LT0(1 + z02 + z12, 1 + 0 + 0) :|: z = 1 + z02 + z12, z1 >= 0, z' = 1 + z1 + z2, z02 >= 0, z12 >= 0, z2 >= 0
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](lt0(z12, 0), 1 + z02 + z12, 1 + z1 + z2), 0) + LT0(1 + z02 + z12, 1 + 0 + 0) :|: z = 1 + z02 + z12, z1 >= 0, z' = 1 + z1 + z2, z02 >= 0, z12 >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z02 + z12 = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(0, f[Ite][False][Ite](lt0(z11, 0), 1 + z01 + z11, 1 + z1 + z2)) + LT0(1 + z01 + z11, 1 + 0 + 0) :|: z11 >= 0, z1 >= 0, z01 >= 0, z = 1 + z01 + z11, z' = 1 + z1 + z2, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z01 + z11 = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(0, f[Ite][False][Ite](lt0(z13, 0), 1 + z03 + z13, 1 + z1 + z2)) + LT0(1 + z03 + z13, 1 + 0 + 0) :|: z = 1 + z03 + z13, z1 >= 0, z' = 1 + z1 + z2, z03 >= 0, z13 >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z03 + z13 = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(0, 0) + LT0(z, 1 + 0 + 0) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, 0 = v0, v2 >= 0, v0' >= 0, 1 + z1 + z2 = v2', 0 = v0', v2' >= 0
   G(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   G(z, z') -{ 1 }-> 1 + G[ITE][FALSE][ITE](lt0(z1', 0), 1 + z0' + z1', 1 + z1 + z2) + LT0(1 + z0' + z1', 1 + 0 + 0) :|: z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0
   G(z, z') -{ 1 }-> 1 + G[ITE][FALSE][ITE](0, z, 1 + z1 + z2) + LT0(z, 1 + 0 + 0) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z', z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z1, 1 + (1 + 0 + 0) + z'') :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z'' >= 0
   LT0(z, z') -{ 1 }-> 1 + LT0(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z' :|: z = 2, z'' >= 0, z' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z2 :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 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'' >= 0, z = 1, z' >= 0
   lt0(z, z') -{ 0 }-> lt0(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   lt0(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0


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

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

   { lt0 }
   { LT0 }
   { f[Ite][False][Ite] }
   { F }
   { G, G[ITE][FALSE][ITE] }

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

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

   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](lt0(z1'', 0), 1 + z0'' + z1'', 1 + z1 + z2), f[Ite][False][Ite](lt0(z1'', 0), 1 + z0'' + z1'', 1 + z1 + z2)) + LT0(1 + z0'' + z1'', 1 + 0 + 0) :|: z = 1 + z0'' + z1'', z1 >= 0, z' = 1 + z1 + z2, z0'' >= 0, z2 >= 0, z1'' >= 0
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](lt0(z1'', 0), 1 + z0'' + z1'', 1 + z1 + z2), 0) + LT0(1 + z0'' + z1'', 1 + 0 + 0) :|: z = 1 + z0'' + z1'', z1 >= 0, z' = 1 + z1 + z2, z0'' >= 0, z2 >= 0, z1'' >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z0'' + z1'' = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](lt0(z12, 0), 1 + z02 + z12, 1 + z1 + z2), f[Ite][False][Ite](lt0(z12, 0), 1 + z02 + z12, 1 + z1 + z2)) + LT0(1 + z02 + z12, 1 + 0 + 0) :|: z = 1 + z02 + z12, z1 >= 0, z' = 1 + z1 + z2, z02 >= 0, z12 >= 0, z2 >= 0
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](lt0(z12, 0), 1 + z02 + z12, 1 + z1 + z2), 0) + LT0(1 + z02 + z12, 1 + 0 + 0) :|: z = 1 + z02 + z12, z1 >= 0, z' = 1 + z1 + z2, z02 >= 0, z12 >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z02 + z12 = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(0, f[Ite][False][Ite](lt0(z11, 0), 1 + z01 + z11, 1 + z1 + z2)) + LT0(1 + z01 + z11, 1 + 0 + 0) :|: z11 >= 0, z1 >= 0, z01 >= 0, z = 1 + z01 + z11, z' = 1 + z1 + z2, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z01 + z11 = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(0, f[Ite][False][Ite](lt0(z13, 0), 1 + z03 + z13, 1 + z1 + z2)) + LT0(1 + z03 + z13, 1 + 0 + 0) :|: z = 1 + z03 + z13, z1 >= 0, z' = 1 + z1 + z2, z03 >= 0, z13 >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z03 + z13 = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(0, 0) + LT0(z, 1 + 0 + 0) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, 0 = v0, v2 >= 0, v0' >= 0, 1 + z1 + z2 = v2', 0 = v0', v2' >= 0
   G(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   G(z, z') -{ 1 }-> 1 + G[ITE][FALSE][ITE](lt0(z1', 0), 1 + z0' + z1', 1 + z1 + z2) + LT0(1 + z0' + z1', 1 + 0 + 0) :|: z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0
   G(z, z') -{ 1 }-> 1 + G[ITE][FALSE][ITE](0, z, 1 + z1 + z2) + LT0(z, 1 + 0 + 0) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z', z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z1, 1 + (1 + 0 + 0) + z'') :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z'' >= 0
   LT0(z, z') -{ 1 }-> 1 + LT0(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z' :|: z = 2, z'' >= 0, z' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z2 :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 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'' >= 0, z = 1, z' >= 0
   lt0(z, z') -{ 0 }-> lt0(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   lt0(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {lt0}, {LT0}, {f[Ite][False][Ite]}, {F}, {G,G[ITE][FALSE][ITE]}

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

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

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

   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](lt0(z1'', 0), 1 + z0'' + z1'', 1 + z1 + z2), f[Ite][False][Ite](lt0(z1'', 0), 1 + z0'' + z1'', 1 + z1 + z2)) + LT0(1 + z0'' + z1'', 1 + 0 + 0) :|: z = 1 + z0'' + z1'', z1 >= 0, z' = 1 + z1 + z2, z0'' >= 0, z2 >= 0, z1'' >= 0
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](lt0(z1'', 0), 1 + z0'' + z1'', 1 + z1 + z2), 0) + LT0(1 + z0'' + z1'', 1 + 0 + 0) :|: z = 1 + z0'' + z1'', z1 >= 0, z' = 1 + z1 + z2, z0'' >= 0, z2 >= 0, z1'' >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z0'' + z1'' = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](lt0(z12, 0), 1 + z02 + z12, 1 + z1 + z2), f[Ite][False][Ite](lt0(z12, 0), 1 + z02 + z12, 1 + z1 + z2)) + LT0(1 + z02 + z12, 1 + 0 + 0) :|: z = 1 + z02 + z12, z1 >= 0, z' = 1 + z1 + z2, z02 >= 0, z12 >= 0, z2 >= 0
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](lt0(z12, 0), 1 + z02 + z12, 1 + z1 + z2), 0) + LT0(1 + z02 + z12, 1 + 0 + 0) :|: z = 1 + z02 + z12, z1 >= 0, z' = 1 + z1 + z2, z02 >= 0, z12 >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z02 + z12 = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(0, f[Ite][False][Ite](lt0(z11, 0), 1 + z01 + z11, 1 + z1 + z2)) + LT0(1 + z01 + z11, 1 + 0 + 0) :|: z11 >= 0, z1 >= 0, z01 >= 0, z = 1 + z01 + z11, z' = 1 + z1 + z2, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z01 + z11 = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(0, f[Ite][False][Ite](lt0(z13, 0), 1 + z03 + z13, 1 + z1 + z2)) + LT0(1 + z03 + z13, 1 + 0 + 0) :|: z = 1 + z03 + z13, z1 >= 0, z' = 1 + z1 + z2, z03 >= 0, z13 >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z03 + z13 = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(0, 0) + LT0(z, 1 + 0 + 0) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, 0 = v0, v2 >= 0, v0' >= 0, 1 + z1 + z2 = v2', 0 = v0', v2' >= 0
   G(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   G(z, z') -{ 1 }-> 1 + G[ITE][FALSE][ITE](lt0(z1', 0), 1 + z0' + z1', 1 + z1 + z2) + LT0(1 + z0' + z1', 1 + 0 + 0) :|: z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0
   G(z, z') -{ 1 }-> 1 + G[ITE][FALSE][ITE](0, z, 1 + z1 + z2) + LT0(z, 1 + 0 + 0) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z', z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z1, 1 + (1 + 0 + 0) + z'') :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z'' >= 0
   LT0(z, z') -{ 1 }-> 1 + LT0(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z' :|: z = 2, z'' >= 0, z' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z2 :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 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'' >= 0, z = 1, z' >= 0
   lt0(z, z') -{ 0 }-> lt0(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   lt0(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {lt0}, {LT0}, {f[Ite][False][Ite]}, {F}, {G,G[ITE][FALSE][ITE]}

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

(55) 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

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

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

   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](lt0(z1'', 0), 1 + z0'' + z1'', 1 + z1 + z2), f[Ite][False][Ite](lt0(z1'', 0), 1 + z0'' + z1'', 1 + z1 + z2)) + LT0(1 + z0'' + z1'', 1 + 0 + 0) :|: z = 1 + z0'' + z1'', z1 >= 0, z' = 1 + z1 + z2, z0'' >= 0, z2 >= 0, z1'' >= 0
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](lt0(z1'', 0), 1 + z0'' + z1'', 1 + z1 + z2), 0) + LT0(1 + z0'' + z1'', 1 + 0 + 0) :|: z = 1 + z0'' + z1'', z1 >= 0, z' = 1 + z1 + z2, z0'' >= 0, z2 >= 0, z1'' >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z0'' + z1'' = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](lt0(z12, 0), 1 + z02 + z12, 1 + z1 + z2), f[Ite][False][Ite](lt0(z12, 0), 1 + z02 + z12, 1 + z1 + z2)) + LT0(1 + z02 + z12, 1 + 0 + 0) :|: z = 1 + z02 + z12, z1 >= 0, z' = 1 + z1 + z2, z02 >= 0, z12 >= 0, z2 >= 0
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](lt0(z12, 0), 1 + z02 + z12, 1 + z1 + z2), 0) + LT0(1 + z02 + z12, 1 + 0 + 0) :|: z = 1 + z02 + z12, z1 >= 0, z' = 1 + z1 + z2, z02 >= 0, z12 >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z02 + z12 = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(0, f[Ite][False][Ite](lt0(z11, 0), 1 + z01 + z11, 1 + z1 + z2)) + LT0(1 + z01 + z11, 1 + 0 + 0) :|: z11 >= 0, z1 >= 0, z01 >= 0, z = 1 + z01 + z11, z' = 1 + z1 + z2, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z01 + z11 = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(0, f[Ite][False][Ite](lt0(z13, 0), 1 + z03 + z13, 1 + z1 + z2)) + LT0(1 + z03 + z13, 1 + 0 + 0) :|: z = 1 + z03 + z13, z1 >= 0, z' = 1 + z1 + z2, z03 >= 0, z13 >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z03 + z13 = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(0, 0) + LT0(z, 1 + 0 + 0) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, 0 = v0, v2 >= 0, v0' >= 0, 1 + z1 + z2 = v2', 0 = v0', v2' >= 0
   G(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   G(z, z') -{ 1 }-> 1 + G[ITE][FALSE][ITE](lt0(z1', 0), 1 + z0' + z1', 1 + z1 + z2) + LT0(1 + z0' + z1', 1 + 0 + 0) :|: z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0
   G(z, z') -{ 1 }-> 1 + G[ITE][FALSE][ITE](0, z, 1 + z1 + z2) + LT0(z, 1 + 0 + 0) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z', z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z1, 1 + (1 + 0 + 0) + z'') :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z'' >= 0
   LT0(z, z') -{ 1 }-> 1 + LT0(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z' :|: z = 2, z'' >= 0, z' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z2 :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 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'' >= 0, z = 1, z' >= 0
   lt0(z, z') -{ 0 }-> lt0(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   lt0(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {lt0}, {LT0}, {f[Ite][False][Ite]}, {F}, {G,G[ITE][FALSE][ITE]}
Previous analysis results are:
  lt0: runtime: ?, size: O(1) [1]

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

(57) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](lt0(z1'', 0), 1 + z0'' + z1'', 1 + z1 + z2), f[Ite][False][Ite](lt0(z1'', 0), 1 + z0'' + z1'', 1 + z1 + z2)) + LT0(1 + z0'' + z1'', 1 + 0 + 0) :|: z = 1 + z0'' + z1'', z1 >= 0, z' = 1 + z1 + z2, z0'' >= 0, z2 >= 0, z1'' >= 0
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](lt0(z1'', 0), 1 + z0'' + z1'', 1 + z1 + z2), 0) + LT0(1 + z0'' + z1'', 1 + 0 + 0) :|: z = 1 + z0'' + z1'', z1 >= 0, z' = 1 + z1 + z2, z0'' >= 0, z2 >= 0, z1'' >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z0'' + z1'' = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](lt0(z12, 0), 1 + z02 + z12, 1 + z1 + z2), f[Ite][False][Ite](lt0(z12, 0), 1 + z02 + z12, 1 + z1 + z2)) + LT0(1 + z02 + z12, 1 + 0 + 0) :|: z = 1 + z02 + z12, z1 >= 0, z' = 1 + z1 + z2, z02 >= 0, z12 >= 0, z2 >= 0
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](lt0(z12, 0), 1 + z02 + z12, 1 + z1 + z2), 0) + LT0(1 + z02 + z12, 1 + 0 + 0) :|: z = 1 + z02 + z12, z1 >= 0, z' = 1 + z1 + z2, z02 >= 0, z12 >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z02 + z12 = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(0, f[Ite][False][Ite](lt0(z11, 0), 1 + z01 + z11, 1 + z1 + z2)) + LT0(1 + z01 + z11, 1 + 0 + 0) :|: z11 >= 0, z1 >= 0, z01 >= 0, z = 1 + z01 + z11, z' = 1 + z1 + z2, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z01 + z11 = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(0, f[Ite][False][Ite](lt0(z13, 0), 1 + z03 + z13, 1 + z1 + z2)) + LT0(1 + z03 + z13, 1 + 0 + 0) :|: z = 1 + z03 + z13, z1 >= 0, z' = 1 + z1 + z2, z03 >= 0, z13 >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z03 + z13 = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(0, 0) + LT0(z, 1 + 0 + 0) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, 0 = v0, v2 >= 0, v0' >= 0, 1 + z1 + z2 = v2', 0 = v0', v2' >= 0
   G(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   G(z, z') -{ 1 }-> 1 + G[ITE][FALSE][ITE](lt0(z1', 0), 1 + z0' + z1', 1 + z1 + z2) + LT0(1 + z0' + z1', 1 + 0 + 0) :|: z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0
   G(z, z') -{ 1 }-> 1 + G[ITE][FALSE][ITE](0, z, 1 + z1 + z2) + LT0(z, 1 + 0 + 0) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z', z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z1, 1 + (1 + 0 + 0) + z'') :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z'' >= 0
   LT0(z, z') -{ 1 }-> 1 + LT0(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z' :|: z = 2, z'' >= 0, z' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z2 :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 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'' >= 0, z = 1, z' >= 0
   lt0(z, z') -{ 0 }-> lt0(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   lt0(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {LT0}, {f[Ite][False][Ite]}, {F}, {G,G[ITE][FALSE][ITE]}
Previous analysis results are:
  lt0: runtime: O(1) [0], size: O(1) [1]

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

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

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

   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](s'', 1 + z0'' + z1'', 1 + z1 + z2), f[Ite][False][Ite](s1, 1 + z0'' + z1'', 1 + z1 + z2)) + LT0(1 + z0'' + z1'', 1 + 0 + 0) :|: s'' >= 0, s'' <= 1, s1 >= 0, s1 <= 1, z = 1 + z0'' + z1'', z1 >= 0, z' = 1 + z1 + z2, z0'' >= 0, z2 >= 0, z1'' >= 0
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](s2, 1 + z0'' + z1'', 1 + z1 + z2), 0) + LT0(1 + z0'' + z1'', 1 + 0 + 0) :|: s2 >= 0, s2 <= 1, z = 1 + z0'' + z1'', z1 >= 0, z' = 1 + z1 + z2, z0'' >= 0, z2 >= 0, z1'' >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z0'' + z1'' = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](s4, 1 + z02 + z12, 1 + z1 + z2), f[Ite][False][Ite](s5, 1 + z02 + z12, 1 + z1 + z2)) + LT0(1 + z02 + z12, 1 + 0 + 0) :|: s4 >= 0, s4 <= 1, s5 >= 0, s5 <= 1, z = 1 + z02 + z12, z1 >= 0, z' = 1 + z1 + z2, z02 >= 0, z12 >= 0, z2 >= 0
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](s6, 1 + z02 + z12, 1 + z1 + z2), 0) + LT0(1 + z02 + z12, 1 + 0 + 0) :|: s6 >= 0, s6 <= 1, z = 1 + z02 + z12, z1 >= 0, z' = 1 + z1 + z2, z02 >= 0, z12 >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z02 + z12 = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(0, f[Ite][False][Ite](s3, 1 + z01 + z11, 1 + z1 + z2)) + LT0(1 + z01 + z11, 1 + 0 + 0) :|: s3 >= 0, s3 <= 1, z11 >= 0, z1 >= 0, z01 >= 0, z = 1 + z01 + z11, z' = 1 + z1 + z2, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z01 + z11 = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(0, f[Ite][False][Ite](s7, 1 + z03 + z13, 1 + z1 + z2)) + LT0(1 + z03 + z13, 1 + 0 + 0) :|: s7 >= 0, s7 <= 1, z = 1 + z03 + z13, z1 >= 0, z' = 1 + z1 + z2, z03 >= 0, z13 >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z03 + z13 = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(0, 0) + LT0(z, 1 + 0 + 0) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, 0 = v0, v2 >= 0, v0' >= 0, 1 + z1 + z2 = v2', 0 = v0', v2' >= 0
   G(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   G(z, z') -{ 1 }-> 1 + G[ITE][FALSE][ITE](s, 1 + z0' + z1', 1 + z1 + z2) + LT0(1 + z0' + z1', 1 + 0 + 0) :|: s >= 0, s <= 1, z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0
   G(z, z') -{ 1 }-> 1 + G[ITE][FALSE][ITE](0, z, 1 + z1 + z2) + LT0(z, 1 + 0 + 0) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z', z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z1, 1 + (1 + 0 + 0) + z'') :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z'' >= 0
   LT0(z, z') -{ 1 }-> 1 + LT0(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z' :|: z = 2, z'' >= 0, z' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z2 :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 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'' >= 0, z = 1, z' >= 0
   lt0(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 1, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   lt0(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {LT0}, {f[Ite][False][Ite]}, {F}, {G,G[ITE][FALSE][ITE]}
Previous analysis results are:
  lt0: runtime: O(1) [0], size: O(1) [1]

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

(61) 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: 0

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

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

   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](s'', 1 + z0'' + z1'', 1 + z1 + z2), f[Ite][False][Ite](s1, 1 + z0'' + z1'', 1 + z1 + z2)) + LT0(1 + z0'' + z1'', 1 + 0 + 0) :|: s'' >= 0, s'' <= 1, s1 >= 0, s1 <= 1, z = 1 + z0'' + z1'', z1 >= 0, z' = 1 + z1 + z2, z0'' >= 0, z2 >= 0, z1'' >= 0
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](s2, 1 + z0'' + z1'', 1 + z1 + z2), 0) + LT0(1 + z0'' + z1'', 1 + 0 + 0) :|: s2 >= 0, s2 <= 1, z = 1 + z0'' + z1'', z1 >= 0, z' = 1 + z1 + z2, z0'' >= 0, z2 >= 0, z1'' >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z0'' + z1'' = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](s4, 1 + z02 + z12, 1 + z1 + z2), f[Ite][False][Ite](s5, 1 + z02 + z12, 1 + z1 + z2)) + LT0(1 + z02 + z12, 1 + 0 + 0) :|: s4 >= 0, s4 <= 1, s5 >= 0, s5 <= 1, z = 1 + z02 + z12, z1 >= 0, z' = 1 + z1 + z2, z02 >= 0, z12 >= 0, z2 >= 0
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](s6, 1 + z02 + z12, 1 + z1 + z2), 0) + LT0(1 + z02 + z12, 1 + 0 + 0) :|: s6 >= 0, s6 <= 1, z = 1 + z02 + z12, z1 >= 0, z' = 1 + z1 + z2, z02 >= 0, z12 >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z02 + z12 = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(0, f[Ite][False][Ite](s3, 1 + z01 + z11, 1 + z1 + z2)) + LT0(1 + z01 + z11, 1 + 0 + 0) :|: s3 >= 0, s3 <= 1, z11 >= 0, z1 >= 0, z01 >= 0, z = 1 + z01 + z11, z' = 1 + z1 + z2, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z01 + z11 = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(0, f[Ite][False][Ite](s7, 1 + z03 + z13, 1 + z1 + z2)) + LT0(1 + z03 + z13, 1 + 0 + 0) :|: s7 >= 0, s7 <= 1, z = 1 + z03 + z13, z1 >= 0, z' = 1 + z1 + z2, z03 >= 0, z13 >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z03 + z13 = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(0, 0) + LT0(z, 1 + 0 + 0) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, 0 = v0, v2 >= 0, v0' >= 0, 1 + z1 + z2 = v2', 0 = v0', v2' >= 0
   G(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   G(z, z') -{ 1 }-> 1 + G[ITE][FALSE][ITE](s, 1 + z0' + z1', 1 + z1 + z2) + LT0(1 + z0' + z1', 1 + 0 + 0) :|: s >= 0, s <= 1, z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0
   G(z, z') -{ 1 }-> 1 + G[ITE][FALSE][ITE](0, z, 1 + z1 + z2) + LT0(z, 1 + 0 + 0) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z', z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z1, 1 + (1 + 0 + 0) + z'') :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z'' >= 0
   LT0(z, z') -{ 1 }-> 1 + LT0(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z' :|: z = 2, z'' >= 0, z' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z2 :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 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'' >= 0, z = 1, z' >= 0
   lt0(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 1, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   lt0(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {LT0}, {f[Ite][False][Ite]}, {F}, {G,G[ITE][FALSE][ITE]}
Previous analysis results are:
  lt0: runtime: O(1) [0], size: O(1) [1]
  LT0: runtime: ?, size: O(1) [0]

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

(63) 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: z'

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

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

   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](s'', 1 + z0'' + z1'', 1 + z1 + z2), f[Ite][False][Ite](s1, 1 + z0'' + z1'', 1 + z1 + z2)) + LT0(1 + z0'' + z1'', 1 + 0 + 0) :|: s'' >= 0, s'' <= 1, s1 >= 0, s1 <= 1, z = 1 + z0'' + z1'', z1 >= 0, z' = 1 + z1 + z2, z0'' >= 0, z2 >= 0, z1'' >= 0
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](s2, 1 + z0'' + z1'', 1 + z1 + z2), 0) + LT0(1 + z0'' + z1'', 1 + 0 + 0) :|: s2 >= 0, s2 <= 1, z = 1 + z0'' + z1'', z1 >= 0, z' = 1 + z1 + z2, z0'' >= 0, z2 >= 0, z1'' >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z0'' + z1'' = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](s4, 1 + z02 + z12, 1 + z1 + z2), f[Ite][False][Ite](s5, 1 + z02 + z12, 1 + z1 + z2)) + LT0(1 + z02 + z12, 1 + 0 + 0) :|: s4 >= 0, s4 <= 1, s5 >= 0, s5 <= 1, z = 1 + z02 + z12, z1 >= 0, z' = 1 + z1 + z2, z02 >= 0, z12 >= 0, z2 >= 0
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](s6, 1 + z02 + z12, 1 + z1 + z2), 0) + LT0(1 + z02 + z12, 1 + 0 + 0) :|: s6 >= 0, s6 <= 1, z = 1 + z02 + z12, z1 >= 0, z' = 1 + z1 + z2, z02 >= 0, z12 >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z02 + z12 = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(0, f[Ite][False][Ite](s3, 1 + z01 + z11, 1 + z1 + z2)) + LT0(1 + z01 + z11, 1 + 0 + 0) :|: s3 >= 0, s3 <= 1, z11 >= 0, z1 >= 0, z01 >= 0, z = 1 + z01 + z11, z' = 1 + z1 + z2, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z01 + z11 = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(0, f[Ite][False][Ite](s7, 1 + z03 + z13, 1 + z1 + z2)) + LT0(1 + z03 + z13, 1 + 0 + 0) :|: s7 >= 0, s7 <= 1, z = 1 + z03 + z13, z1 >= 0, z' = 1 + z1 + z2, z03 >= 0, z13 >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z03 + z13 = v1, v2 >= 0
   F(z, z') -{ 1 }-> 1 + F(0, 0) + LT0(z, 1 + 0 + 0) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, 0 = v0, v2 >= 0, v0' >= 0, 1 + z1 + z2 = v2', 0 = v0', v2' >= 0
   G(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   G(z, z') -{ 1 }-> 1 + G[ITE][FALSE][ITE](s, 1 + z0' + z1', 1 + z1 + z2) + LT0(1 + z0' + z1', 1 + 0 + 0) :|: s >= 0, s <= 1, z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0
   G(z, z') -{ 1 }-> 1 + G[ITE][FALSE][ITE](0, z, 1 + z1 + z2) + LT0(z, 1 + 0 + 0) :|: z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z', z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z1, 1 + (1 + 0 + 0) + z'') :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z'' >= 0
   LT0(z, z') -{ 1 }-> 1 + LT0(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z' :|: z = 2, z'' >= 0, z' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z2 :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 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'' >= 0, z = 1, z' >= 0
   lt0(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 1, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   lt0(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {f[Ite][False][Ite]}, {F}, {G,G[ITE][FALSE][ITE]}
Previous analysis results are:
  lt0: runtime: O(1) [0], size: O(1) [1]
  LT0: runtime: O(n^1) [z'], size: O(1) [0]

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

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

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

   F(z, z') -{ 2 }-> 1 + F(f[Ite][False][Ite](s'', 1 + z0'' + z1'', 1 + z1 + z2), f[Ite][False][Ite](s1, 1 + z0'' + z1'', 1 + z1 + z2)) + s11 :|: s11 >= 0, s11 <= 0, s'' >= 0, s'' <= 1, s1 >= 0, s1 <= 1, z = 1 + z0'' + z1'', z1 >= 0, z' = 1 + z1 + z2, z0'' >= 0, z2 >= 0, z1'' >= 0
   F(z, z') -{ 2 }-> 1 + F(f[Ite][False][Ite](s2, 1 + z0'' + z1'', 1 + z1 + z2), 0) + s12 :|: s12 >= 0, s12 <= 0, s2 >= 0, s2 <= 1, z = 1 + z0'' + z1'', z1 >= 0, z' = 1 + z1 + z2, z0'' >= 0, z2 >= 0, z1'' >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z0'' + z1'' = v1, v2 >= 0
   F(z, z') -{ 2 }-> 1 + F(f[Ite][False][Ite](s4, 1 + z02 + z12, 1 + z1 + z2), f[Ite][False][Ite](s5, 1 + z02 + z12, 1 + z1 + z2)) + s15 :|: s15 >= 0, s15 <= 0, s4 >= 0, s4 <= 1, s5 >= 0, s5 <= 1, z = 1 + z02 + z12, z1 >= 0, z' = 1 + z1 + z2, z02 >= 0, z12 >= 0, z2 >= 0
   F(z, z') -{ 2 }-> 1 + F(f[Ite][False][Ite](s6, 1 + z02 + z12, 1 + z1 + z2), 0) + s16 :|: s16 >= 0, s16 <= 0, s6 >= 0, s6 <= 1, z = 1 + z02 + z12, z1 >= 0, z' = 1 + z1 + z2, z02 >= 0, z12 >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z02 + z12 = v1, v2 >= 0
   F(z, z') -{ 2 }-> 1 + F(0, f[Ite][False][Ite](s3, 1 + z01 + z11, 1 + z1 + z2)) + s13 :|: s13 >= 0, s13 <= 0, s3 >= 0, s3 <= 1, z11 >= 0, z1 >= 0, z01 >= 0, z = 1 + z01 + z11, z' = 1 + z1 + z2, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z01 + z11 = v1, v2 >= 0
   F(z, z') -{ 2 }-> 1 + F(0, f[Ite][False][Ite](s7, 1 + z03 + z13, 1 + z1 + z2)) + s17 :|: s17 >= 0, s17 <= 0, s7 >= 0, s7 <= 1, z = 1 + z03 + z13, z1 >= 0, z' = 1 + z1 + z2, z03 >= 0, z13 >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z03 + z13 = v1, v2 >= 0
   F(z, z') -{ 2 }-> 1 + F(0, 0) + s14 :|: s14 >= 0, s14 <= 0, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, 0 = v0, v2 >= 0, v0' >= 0, 1 + z1 + z2 = v2', 0 = v0', v2' >= 0
   G(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   G(z, z') -{ 2 }-> 1 + G[ITE][FALSE][ITE](s, 1 + z0' + z1', 1 + z1 + z2) + s9 :|: s9 >= 0, s9 <= 0, s >= 0, s <= 1, z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0
   G(z, z') -{ 2 }-> 1 + G[ITE][FALSE][ITE](0, z, 1 + z1 + z2) + s10 :|: s10 >= 0, s10 <= 0, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z', z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z1, 1 + (1 + 0 + 0) + z'') :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z'' >= 0
   LT0(z, z') -{ 1 + z3 }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z' :|: z = 2, z'' >= 0, z' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z2 :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 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'' >= 0, z = 1, z' >= 0
   lt0(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 1, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   lt0(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {f[Ite][False][Ite]}, {F}, {G,G[ITE][FALSE][ITE]}
Previous analysis results are:
  lt0: runtime: O(1) [0], size: O(1) [1]
  LT0: runtime: O(n^1) [z'], size: O(1) [0]

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

(67) 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''

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

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

   F(z, z') -{ 2 }-> 1 + F(f[Ite][False][Ite](s'', 1 + z0'' + z1'', 1 + z1 + z2), f[Ite][False][Ite](s1, 1 + z0'' + z1'', 1 + z1 + z2)) + s11 :|: s11 >= 0, s11 <= 0, s'' >= 0, s'' <= 1, s1 >= 0, s1 <= 1, z = 1 + z0'' + z1'', z1 >= 0, z' = 1 + z1 + z2, z0'' >= 0, z2 >= 0, z1'' >= 0
   F(z, z') -{ 2 }-> 1 + F(f[Ite][False][Ite](s2, 1 + z0'' + z1'', 1 + z1 + z2), 0) + s12 :|: s12 >= 0, s12 <= 0, s2 >= 0, s2 <= 1, z = 1 + z0'' + z1'', z1 >= 0, z' = 1 + z1 + z2, z0'' >= 0, z2 >= 0, z1'' >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z0'' + z1'' = v1, v2 >= 0
   F(z, z') -{ 2 }-> 1 + F(f[Ite][False][Ite](s4, 1 + z02 + z12, 1 + z1 + z2), f[Ite][False][Ite](s5, 1 + z02 + z12, 1 + z1 + z2)) + s15 :|: s15 >= 0, s15 <= 0, s4 >= 0, s4 <= 1, s5 >= 0, s5 <= 1, z = 1 + z02 + z12, z1 >= 0, z' = 1 + z1 + z2, z02 >= 0, z12 >= 0, z2 >= 0
   F(z, z') -{ 2 }-> 1 + F(f[Ite][False][Ite](s6, 1 + z02 + z12, 1 + z1 + z2), 0) + s16 :|: s16 >= 0, s16 <= 0, s6 >= 0, s6 <= 1, z = 1 + z02 + z12, z1 >= 0, z' = 1 + z1 + z2, z02 >= 0, z12 >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z02 + z12 = v1, v2 >= 0
   F(z, z') -{ 2 }-> 1 + F(0, f[Ite][False][Ite](s3, 1 + z01 + z11, 1 + z1 + z2)) + s13 :|: s13 >= 0, s13 <= 0, s3 >= 0, s3 <= 1, z11 >= 0, z1 >= 0, z01 >= 0, z = 1 + z01 + z11, z' = 1 + z1 + z2, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z01 + z11 = v1, v2 >= 0
   F(z, z') -{ 2 }-> 1 + F(0, f[Ite][False][Ite](s7, 1 + z03 + z13, 1 + z1 + z2)) + s17 :|: s17 >= 0, s17 <= 0, s7 >= 0, s7 <= 1, z = 1 + z03 + z13, z1 >= 0, z' = 1 + z1 + z2, z03 >= 0, z13 >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z03 + z13 = v1, v2 >= 0
   F(z, z') -{ 2 }-> 1 + F(0, 0) + s14 :|: s14 >= 0, s14 <= 0, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, 0 = v0, v2 >= 0, v0' >= 0, 1 + z1 + z2 = v2', 0 = v0', v2' >= 0
   G(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   G(z, z') -{ 2 }-> 1 + G[ITE][FALSE][ITE](s, 1 + z0' + z1', 1 + z1 + z2) + s9 :|: s9 >= 0, s9 <= 0, s >= 0, s <= 1, z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0
   G(z, z') -{ 2 }-> 1 + G[ITE][FALSE][ITE](0, z, 1 + z1 + z2) + s10 :|: s10 >= 0, s10 <= 0, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z', z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z1, 1 + (1 + 0 + 0) + z'') :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z'' >= 0
   LT0(z, z') -{ 1 + z3 }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z' :|: z = 2, z'' >= 0, z' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z2 :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 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'' >= 0, z = 1, z' >= 0
   lt0(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 1, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   lt0(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {f[Ite][False][Ite]}, {F}, {G,G[ITE][FALSE][ITE]}
Previous analysis results are:
  lt0: runtime: O(1) [0], size: O(1) [1]
  LT0: runtime: O(n^1) [z'], size: O(1) [0]
  f[Ite][False][Ite]: runtime: ?, size: O(n^1) [2 + z' + z'']

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

(69) 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

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

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

   F(z, z') -{ 2 }-> 1 + F(f[Ite][False][Ite](s'', 1 + z0'' + z1'', 1 + z1 + z2), f[Ite][False][Ite](s1, 1 + z0'' + z1'', 1 + z1 + z2)) + s11 :|: s11 >= 0, s11 <= 0, s'' >= 0, s'' <= 1, s1 >= 0, s1 <= 1, z = 1 + z0'' + z1'', z1 >= 0, z' = 1 + z1 + z2, z0'' >= 0, z2 >= 0, z1'' >= 0
   F(z, z') -{ 2 }-> 1 + F(f[Ite][False][Ite](s2, 1 + z0'' + z1'', 1 + z1 + z2), 0) + s12 :|: s12 >= 0, s12 <= 0, s2 >= 0, s2 <= 1, z = 1 + z0'' + z1'', z1 >= 0, z' = 1 + z1 + z2, z0'' >= 0, z2 >= 0, z1'' >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z0'' + z1'' = v1, v2 >= 0
   F(z, z') -{ 2 }-> 1 + F(f[Ite][False][Ite](s4, 1 + z02 + z12, 1 + z1 + z2), f[Ite][False][Ite](s5, 1 + z02 + z12, 1 + z1 + z2)) + s15 :|: s15 >= 0, s15 <= 0, s4 >= 0, s4 <= 1, s5 >= 0, s5 <= 1, z = 1 + z02 + z12, z1 >= 0, z' = 1 + z1 + z2, z02 >= 0, z12 >= 0, z2 >= 0
   F(z, z') -{ 2 }-> 1 + F(f[Ite][False][Ite](s6, 1 + z02 + z12, 1 + z1 + z2), 0) + s16 :|: s16 >= 0, s16 <= 0, s6 >= 0, s6 <= 1, z = 1 + z02 + z12, z1 >= 0, z' = 1 + z1 + z2, z02 >= 0, z12 >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z02 + z12 = v1, v2 >= 0
   F(z, z') -{ 2 }-> 1 + F(0, f[Ite][False][Ite](s3, 1 + z01 + z11, 1 + z1 + z2)) + s13 :|: s13 >= 0, s13 <= 0, s3 >= 0, s3 <= 1, z11 >= 0, z1 >= 0, z01 >= 0, z = 1 + z01 + z11, z' = 1 + z1 + z2, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z01 + z11 = v1, v2 >= 0
   F(z, z') -{ 2 }-> 1 + F(0, f[Ite][False][Ite](s7, 1 + z03 + z13, 1 + z1 + z2)) + s17 :|: s17 >= 0, s17 <= 0, s7 >= 0, s7 <= 1, z = 1 + z03 + z13, z1 >= 0, z' = 1 + z1 + z2, z03 >= 0, z13 >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z03 + z13 = v1, v2 >= 0
   F(z, z') -{ 2 }-> 1 + F(0, 0) + s14 :|: s14 >= 0, s14 <= 0, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, 0 = v0, v2 >= 0, v0' >= 0, 1 + z1 + z2 = v2', 0 = v0', v2' >= 0
   G(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   G(z, z') -{ 2 }-> 1 + G[ITE][FALSE][ITE](s, 1 + z0' + z1', 1 + z1 + z2) + s9 :|: s9 >= 0, s9 <= 0, s >= 0, s <= 1, z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0
   G(z, z') -{ 2 }-> 1 + G[ITE][FALSE][ITE](0, z, 1 + z1 + z2) + s10 :|: s10 >= 0, s10 <= 0, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z', z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z1, 1 + (1 + 0 + 0) + z'') :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z'' >= 0
   LT0(z, z') -{ 1 + z3 }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z' :|: z = 2, z'' >= 0, z' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z2 :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 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'' >= 0, z = 1, z' >= 0
   lt0(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 1, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   lt0(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {F}, {G,G[ITE][FALSE][ITE]}
Previous analysis results are:
  lt0: runtime: O(1) [0], size: O(1) [1]
  LT0: runtime: O(n^1) [z'], size: O(1) [0]
  f[Ite][False][Ite]: runtime: O(1) [0], size: O(n^1) [2 + z' + z'']

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

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

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

   F(z, z') -{ 2 }-> 1 + F(s18, s19) + s11 :|: s18 >= 0, s18 <= 1 + z1 + z2 + 2 + (1 + z0'' + z1''), s19 >= 0, s19 <= 1 + z1 + z2 + 2 + (1 + z0'' + z1''), s11 >= 0, s11 <= 0, s'' >= 0, s'' <= 1, s1 >= 0, s1 <= 1, z = 1 + z0'' + z1'', z1 >= 0, z' = 1 + z1 + z2, z0'' >= 0, z2 >= 0, z1'' >= 0
   F(z, z') -{ 2 }-> 1 + F(s20, 0) + s12 :|: s20 >= 0, s20 <= 1 + z1 + z2 + 2 + (1 + z0'' + z1''), s12 >= 0, s12 <= 0, s2 >= 0, s2 <= 1, z = 1 + z0'' + z1'', z1 >= 0, z' = 1 + z1 + z2, z0'' >= 0, z2 >= 0, z1'' >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z0'' + z1'' = v1, v2 >= 0
   F(z, z') -{ 2 }-> 1 + F(s22, s23) + s15 :|: s22 >= 0, s22 <= 1 + z1 + z2 + 2 + (1 + z02 + z12), s23 >= 0, s23 <= 1 + z1 + z2 + 2 + (1 + z02 + z12), s15 >= 0, s15 <= 0, s4 >= 0, s4 <= 1, s5 >= 0, s5 <= 1, z = 1 + z02 + z12, z1 >= 0, z' = 1 + z1 + z2, z02 >= 0, z12 >= 0, z2 >= 0
   F(z, z') -{ 2 }-> 1 + F(s24, 0) + s16 :|: s24 >= 0, s24 <= 1 + z1 + z2 + 2 + (1 + z02 + z12), s16 >= 0, s16 <= 0, s6 >= 0, s6 <= 1, z = 1 + z02 + z12, z1 >= 0, z' = 1 + z1 + z2, z02 >= 0, z12 >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z02 + z12 = v1, v2 >= 0
   F(z, z') -{ 2 }-> 1 + F(0, s21) + s13 :|: s21 >= 0, s21 <= 1 + z1 + z2 + 2 + (1 + z01 + z11), s13 >= 0, s13 <= 0, s3 >= 0, s3 <= 1, z11 >= 0, z1 >= 0, z01 >= 0, z = 1 + z01 + z11, z' = 1 + z1 + z2, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z01 + z11 = v1, v2 >= 0
   F(z, z') -{ 2 }-> 1 + F(0, s25) + s17 :|: s25 >= 0, s25 <= 1 + z1 + z2 + 2 + (1 + z03 + z13), s17 >= 0, s17 <= 0, s7 >= 0, s7 <= 1, z = 1 + z03 + z13, z1 >= 0, z' = 1 + z1 + z2, z03 >= 0, z13 >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z03 + z13 = v1, v2 >= 0
   F(z, z') -{ 2 }-> 1 + F(0, 0) + s14 :|: s14 >= 0, s14 <= 0, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, 0 = v0, v2 >= 0, v0' >= 0, 1 + z1 + z2 = v2', 0 = v0', v2' >= 0
   G(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   G(z, z') -{ 2 }-> 1 + G[ITE][FALSE][ITE](s, 1 + z0' + z1', 1 + z1 + z2) + s9 :|: s9 >= 0, s9 <= 0, s >= 0, s <= 1, z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0
   G(z, z') -{ 2 }-> 1 + G[ITE][FALSE][ITE](0, z, 1 + z1 + z2) + s10 :|: s10 >= 0, s10 <= 0, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z', z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z1, 1 + (1 + 0 + 0) + z'') :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z'' >= 0
   LT0(z, z') -{ 1 + z3 }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z' :|: z = 2, z'' >= 0, z' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z2 :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 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'' >= 0, z = 1, z' >= 0
   lt0(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 1, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   lt0(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {F}, {G,G[ITE][FALSE][ITE]}
Previous analysis results are:
  lt0: runtime: O(1) [0], size: O(1) [1]
  LT0: runtime: O(n^1) [z'], size: O(1) [0]
  f[Ite][False][Ite]: runtime: O(1) [0], size: O(n^1) [2 + z' + z'']

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

(73) 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: 0

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

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

   F(z, z') -{ 2 }-> 1 + F(s18, s19) + s11 :|: s18 >= 0, s18 <= 1 + z1 + z2 + 2 + (1 + z0'' + z1''), s19 >= 0, s19 <= 1 + z1 + z2 + 2 + (1 + z0'' + z1''), s11 >= 0, s11 <= 0, s'' >= 0, s'' <= 1, s1 >= 0, s1 <= 1, z = 1 + z0'' + z1'', z1 >= 0, z' = 1 + z1 + z2, z0'' >= 0, z2 >= 0, z1'' >= 0
   F(z, z') -{ 2 }-> 1 + F(s20, 0) + s12 :|: s20 >= 0, s20 <= 1 + z1 + z2 + 2 + (1 + z0'' + z1''), s12 >= 0, s12 <= 0, s2 >= 0, s2 <= 1, z = 1 + z0'' + z1'', z1 >= 0, z' = 1 + z1 + z2, z0'' >= 0, z2 >= 0, z1'' >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z0'' + z1'' = v1, v2 >= 0
   F(z, z') -{ 2 }-> 1 + F(s22, s23) + s15 :|: s22 >= 0, s22 <= 1 + z1 + z2 + 2 + (1 + z02 + z12), s23 >= 0, s23 <= 1 + z1 + z2 + 2 + (1 + z02 + z12), s15 >= 0, s15 <= 0, s4 >= 0, s4 <= 1, s5 >= 0, s5 <= 1, z = 1 + z02 + z12, z1 >= 0, z' = 1 + z1 + z2, z02 >= 0, z12 >= 0, z2 >= 0
   F(z, z') -{ 2 }-> 1 + F(s24, 0) + s16 :|: s24 >= 0, s24 <= 1 + z1 + z2 + 2 + (1 + z02 + z12), s16 >= 0, s16 <= 0, s6 >= 0, s6 <= 1, z = 1 + z02 + z12, z1 >= 0, z' = 1 + z1 + z2, z02 >= 0, z12 >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z02 + z12 = v1, v2 >= 0
   F(z, z') -{ 2 }-> 1 + F(0, s21) + s13 :|: s21 >= 0, s21 <= 1 + z1 + z2 + 2 + (1 + z01 + z11), s13 >= 0, s13 <= 0, s3 >= 0, s3 <= 1, z11 >= 0, z1 >= 0, z01 >= 0, z = 1 + z01 + z11, z' = 1 + z1 + z2, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z01 + z11 = v1, v2 >= 0
   F(z, z') -{ 2 }-> 1 + F(0, s25) + s17 :|: s25 >= 0, s25 <= 1 + z1 + z2 + 2 + (1 + z03 + z13), s17 >= 0, s17 <= 0, s7 >= 0, s7 <= 1, z = 1 + z03 + z13, z1 >= 0, z' = 1 + z1 + z2, z03 >= 0, z13 >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z03 + z13 = v1, v2 >= 0
   F(z, z') -{ 2 }-> 1 + F(0, 0) + s14 :|: s14 >= 0, s14 <= 0, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, 0 = v0, v2 >= 0, v0' >= 0, 1 + z1 + z2 = v2', 0 = v0', v2' >= 0
   G(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   G(z, z') -{ 2 }-> 1 + G[ITE][FALSE][ITE](s, 1 + z0' + z1', 1 + z1 + z2) + s9 :|: s9 >= 0, s9 <= 0, s >= 0, s <= 1, z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0
   G(z, z') -{ 2 }-> 1 + G[ITE][FALSE][ITE](0, z, 1 + z1 + z2) + s10 :|: s10 >= 0, s10 <= 0, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z', z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z1, 1 + (1 + 0 + 0) + z'') :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z'' >= 0
   LT0(z, z') -{ 1 + z3 }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z' :|: z = 2, z'' >= 0, z' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z2 :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 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'' >= 0, z = 1, z' >= 0
   lt0(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 1, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   lt0(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {F}, {G,G[ITE][FALSE][ITE]}
Previous analysis results are:
  lt0: runtime: O(1) [0], size: O(1) [1]
  LT0: runtime: O(n^1) [z'], size: O(1) [0]
  f[Ite][False][Ite]: runtime: O(1) [0], size: O(n^1) [2 + z' + z'']
  F: runtime: ?, size: O(1) [0]

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

(75) 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: ?

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

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

   F(z, z') -{ 2 }-> 1 + F(s18, s19) + s11 :|: s18 >= 0, s18 <= 1 + z1 + z2 + 2 + (1 + z0'' + z1''), s19 >= 0, s19 <= 1 + z1 + z2 + 2 + (1 + z0'' + z1''), s11 >= 0, s11 <= 0, s'' >= 0, s'' <= 1, s1 >= 0, s1 <= 1, z = 1 + z0'' + z1'', z1 >= 0, z' = 1 + z1 + z2, z0'' >= 0, z2 >= 0, z1'' >= 0
   F(z, z') -{ 2 }-> 1 + F(s20, 0) + s12 :|: s20 >= 0, s20 <= 1 + z1 + z2 + 2 + (1 + z0'' + z1''), s12 >= 0, s12 <= 0, s2 >= 0, s2 <= 1, z = 1 + z0'' + z1'', z1 >= 0, z' = 1 + z1 + z2, z0'' >= 0, z2 >= 0, z1'' >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z0'' + z1'' = v1, v2 >= 0
   F(z, z') -{ 2 }-> 1 + F(s22, s23) + s15 :|: s22 >= 0, s22 <= 1 + z1 + z2 + 2 + (1 + z02 + z12), s23 >= 0, s23 <= 1 + z1 + z2 + 2 + (1 + z02 + z12), s15 >= 0, s15 <= 0, s4 >= 0, s4 <= 1, s5 >= 0, s5 <= 1, z = 1 + z02 + z12, z1 >= 0, z' = 1 + z1 + z2, z02 >= 0, z12 >= 0, z2 >= 0
   F(z, z') -{ 2 }-> 1 + F(s24, 0) + s16 :|: s24 >= 0, s24 <= 1 + z1 + z2 + 2 + (1 + z02 + z12), s16 >= 0, s16 <= 0, s6 >= 0, s6 <= 1, z = 1 + z02 + z12, z1 >= 0, z' = 1 + z1 + z2, z02 >= 0, z12 >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z02 + z12 = v1, v2 >= 0
   F(z, z') -{ 2 }-> 1 + F(0, s21) + s13 :|: s21 >= 0, s21 <= 1 + z1 + z2 + 2 + (1 + z01 + z11), s13 >= 0, s13 <= 0, s3 >= 0, s3 <= 1, z11 >= 0, z1 >= 0, z01 >= 0, z = 1 + z01 + z11, z' = 1 + z1 + z2, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z01 + z11 = v1, v2 >= 0
   F(z, z') -{ 2 }-> 1 + F(0, s25) + s17 :|: s25 >= 0, s25 <= 1 + z1 + z2 + 2 + (1 + z03 + z13), s17 >= 0, s17 <= 0, s7 >= 0, s7 <= 1, z = 1 + z03 + z13, z1 >= 0, z' = 1 + z1 + z2, z03 >= 0, z13 >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, v1 >= 0, 0 = v0, 1 + z03 + z13 = v1, v2 >= 0
   F(z, z') -{ 2 }-> 1 + F(0, 0) + s14 :|: s14 >= 0, s14 <= 0, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0, v0 >= 0, 1 + z1 + z2 = v2, 0 = v0, v2 >= 0, v0' >= 0, 1 + z1 + z2 = v2', 0 = v0', v2' >= 0
   G(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   G(z, z') -{ 2 }-> 1 + G[ITE][FALSE][ITE](s, 1 + z0' + z1', 1 + z1 + z2) + s9 :|: s9 >= 0, s9 <= 0, s >= 0, s <= 1, z1 >= 0, z0' >= 0, z' = 1 + z1 + z2, z1' >= 0, z = 1 + z0' + z1', z2 >= 0
   G(z, z') -{ 2 }-> 1 + G[ITE][FALSE][ITE](0, z, 1 + z1 + z2) + s10 :|: s10 >= 0, s10 <= 0, z1 >= 0, z' = 1 + z1 + z2, z >= 0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z', z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z1, 1 + (1 + 0 + 0) + z'') :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z'' >= 0
   LT0(z, z') -{ 1 + z3 }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z' :|: z = 2, z'' >= 0, z' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z1 :|: z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z'' >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z2 :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z' >= 0, z2 >= 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'' >= 0, z = 1, z' >= 0
   lt0(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 1, z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   lt0(z, z') -{ 0 }-> 1 :|: z >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0

Function symbols to be analyzed: {F}, {G,G[ITE][FALSE][ITE]}
Previous analysis results are:
  lt0: runtime: O(1) [0], size: O(1) [1]
  LT0: runtime: O(n^1) [z'], size: O(1) [0]
  f[Ite][False][Ite]: runtime: O(1) [0], size: O(n^1) [2 + z' + z'']
  F: runtime: INF, size: O(1) [0]

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

(77) 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]
   lt0(v0, v1) -> null_lt0 [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_lt0, null_f[Ite][False][Ite], null_LT0, null_G, null_F

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

(78)
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(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3)) [1]
   G(z0, Nil) -> c8 [1]
   G(z0, Cons(z1, z2)) -> c9(G[ITE][FALSE][ITE](lt0(z0, Cons(Nil, Nil)), z0, Cons(z1, z2)), LT0(z0, Cons(Nil, Nil))) [1]
   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))) [1]
   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))) [1]
   G[ITE][FALSE][ITE](False, Cons(z0, z1), z2) -> c(G(z1, Cons(Cons(Nil, Nil), z2))) [0]
   G[ITE][FALSE][ITE](True, z0, Cons(z1, z2)) -> c1(G(z0, z2)) [0]
   lt0(Cons(z0, z1), Cons(z2, z3)) -> lt0(z1, z3) [0]
   lt0(z0, Nil) -> False [0]
   f[Ite][False][Ite](False, Cons(z0, z1), z2) -> z1 [0]
   f[Ite][False][Ite](True, z0, Cons(z1, z2)) -> z2 [0]
   f[Ite][False][Ite](False, z0, z1) -> Cons(Cons(Nil, Nil), z1) [0]
   f[Ite][False][Ite](True, z0, z1) -> z0 [0]
   G[ITE][FALSE][ITE](v0, v1, v2) -> null_G[ITE][FALSE][ITE] [0]
   lt0(v0, v1) -> null_lt0 [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_f[Ite][False][Ite] -> Cons:Nil:null_f[Ite][False][Ite] -> c6:null_LT0
Cons :: Cons:Nil:null_f[Ite][False][Ite] -> Cons:Nil:null_f[Ite][False][Ite] -> Cons:Nil:null_f[Ite][False][Ite]
c6 :: c6:null_LT0 -> c6:null_LT0
G :: Cons:Nil:null_f[Ite][False][Ite] -> Cons:Nil:null_f[Ite][False][Ite] -> c8:c9:null_G
Nil :: Cons:Nil:null_f[Ite][False][Ite]
c8 :: c8:c9:null_G
c9 :: c:c1:null_G[ITE][FALSE][ITE] -> c6:null_LT0 -> c8:c9:null_G
G[ITE][FALSE][ITE] :: False:True:null_lt0 -> Cons:Nil:null_f[Ite][False][Ite] -> Cons:Nil:null_f[Ite][False][Ite] -> c:c1:null_G[ITE][FALSE][ITE]
lt0 :: Cons:Nil:null_f[Ite][False][Ite] -> Cons:Nil:null_f[Ite][False][Ite] -> False:True:null_lt0
F :: Cons:Nil:null_f[Ite][False][Ite] -> Cons:Nil:null_f[Ite][False][Ite] -> c11:c12:null_F
c11 :: c11:c12:null_F -> c6:null_LT0 -> c11:c12:null_F
f[Ite][False][Ite] :: False:True:null_lt0 -> Cons:Nil:null_f[Ite][False][Ite] -> Cons:Nil:null_f[Ite][False][Ite] -> Cons:Nil:null_f[Ite][False][Ite]
c12 :: c11:c12:null_F -> c6:null_LT0 -> c11:c12:null_F
False :: False:True:null_lt0
c :: c8:c9:null_G -> c:c1:null_G[ITE][FALSE][ITE]
True :: False:True:null_lt0
c1 :: c8:c9:null_G -> c:c1:null_G[ITE][FALSE][ITE]
null_G[ITE][FALSE][ITE] :: c:c1:null_G[ITE][FALSE][ITE]
null_lt0 :: False:True:null_lt0
null_f[Ite][False][Ite] :: Cons:Nil:null_f[Ite][False][Ite]
null_LT0 :: c6:null_LT0
null_G :: c8:c9:null_G
null_F :: c11:c12:null_F

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

(79) 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
   c8 => 0
   False => 1
   True => 2
   null_G[ITE][FALSE][ITE] => 0
   null_lt0 => 0
   null_f[Ite][False][Ite] => 0
   null_LT0 => 0
   null_G => 0
   null_F => 0

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

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

   F(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   F(z, z') -{ 1 }-> 1 + F(f[Ite][False][Ite](lt0(z0, 1 + 0 + 0), z0, 1 + z1 + z2), f[Ite][False][Ite](lt0(z0, 1 + 0 + 0), z0, 1 + z1 + z2)) + LT0(z0, 1 + 0 + 0) :|: z = z0, z1 >= 0, z' = 1 + z1 + z2, z0 >= 0, z2 >= 0
   G(z, z') -{ 1 }-> 0 :|: z = z0, z0 >= 0, z' = 0
   G(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   G(z, z') -{ 1 }-> 1 + G[ITE][FALSE][ITE](lt0(z0, 1 + 0 + 0), z0, 1 + z1 + z2) + LT0(z0, 1 + 0 + 0) :|: z = z0, z1 >= 0, z' = 1 + z1 + z2, z0 >= 0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z0, z2) :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z0 >= 0, z' = z0, z2 >= 0
   G[ITE][FALSE][ITE](z, z', z'') -{ 0 }-> 1 + G(z1, 1 + (1 + 0 + 0) + z2) :|: z'' = z2, z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z2 >= 0
   LT0(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   LT0(z, z') -{ 1 }-> 1 + LT0(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z0 :|: z = 2, z1 >= 0, z0 >= 0, z' = z0, z'' = z1
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z1 :|: z'' = z2, z' = 1 + z0 + z1, z1 >= 0, z = 1, z0 >= 0, z2 >= 0
   f[Ite][False][Ite](z, z', z'') -{ 0 }-> z2 :|: z = 2, z1 >= 0, z'' = 1 + z1 + z2, z0 >= 0, z' = z0, z2 >= 0
   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) + z1 :|: z1 >= 0, z = 1, z0 >= 0, z' = z0, z'' = z1
   lt0(z, z') -{ 0 }-> lt0(z1, z3) :|: z1 >= 0, z' = 1 + z2 + z3, z0 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   lt0(z, z') -{ 0 }-> 1 :|: z = z0, z0 >= 0, z' = 0
   lt0(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1

Only complete derivations are relevant for the runtime complexity.

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

(81) 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]

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

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


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

(83) 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

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

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


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

(85) 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)))

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

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


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

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

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

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


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

(89) 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)))

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

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


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

(91) 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)))

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

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


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

(93) 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)))

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

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


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

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

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

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


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

(97) 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)))

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

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


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

(99) 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)))

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

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


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

(101) 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)))

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

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


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

(103) 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)))

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

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


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

(105) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use 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(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))

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

(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))
   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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
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:   LT0_2, G_2, F_2, G[ITE][FALSE][ITE]_3

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


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

(107) 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)))
----------------------------------------

(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))
   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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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:   LT0_2, G_2, F_2, G[ITE][FALSE][ITE]_3

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


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

(109) 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)))
----------------------------------------

(110)
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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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(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


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

(111) 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)))
----------------------------------------

(112)
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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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(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


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

(113) 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)))
----------------------------------------

(114)
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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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)))
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, c_1, c11_2


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

(115) 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)))
----------------------------------------

(116)
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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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)))
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, c_1, c11_2


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

(117) 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)))
----------------------------------------

(118)
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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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)))
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, G_2, F_2, G[ITE][FALSE][ITE]_3

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


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

(119) 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)))
----------------------------------------

(120)
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](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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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)))
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, G_2, F_2, G[ITE][FALSE][ITE]_3

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


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

(121) 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)))
----------------------------------------

(122)
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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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)))
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, G_2, G[ITE][FALSE][ITE]_3, F_2

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


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

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

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

(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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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)))
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, G_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(125) 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)))

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

(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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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)))
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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(127) 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)))

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

(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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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)))
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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(129) 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)))

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

(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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(131) 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)))

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

(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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(133) 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)))

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

(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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(135) 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)))

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

(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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(137) 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)))

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

(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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(139) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2
   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) = 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

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

(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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(141) 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)))

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

(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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(143) 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)))

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

(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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(145) 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)))

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

(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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(147) 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)))

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

(148)
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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(149) 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)))

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

(150)
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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(151) 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)))

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

(152)
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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(153) 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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2
   POL(G[ITE][FALSE][ITE](x_1, x_2, x_3)) = x_2
   POL(LT0(x_1, x_2)) = 0
   POL(Nil) = [1]
   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

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

(154)
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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(155) 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)))

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

(156)
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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(157) 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)))

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

(158)
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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(159) 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)))

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

(160)
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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(161) 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

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

(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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(163) 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)))

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

(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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(165) 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)))

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

(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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(167) 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)))

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

(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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(169) 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)))

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

(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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(171) 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)))

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

(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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(173) 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)))

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

(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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(175) 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)))

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

(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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(177) 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)))

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

(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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(179) 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)))

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

(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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(181) 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)))

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

(182)
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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(183) 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)))

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

(184)
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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(185) 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)))

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

(186)
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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(187) 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)))

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

(188)
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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(189) 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)))

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

(190)
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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(191) 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)))

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

(192)
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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(193) 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)))

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

(194)
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(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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(195) 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)

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

(196)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
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)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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_2, G[ITE][FALSE][ITE]_3, F_2

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


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

(197) 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(z0, z1), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, z1), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))

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

(198)
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(x0, x1), Cons(x2, x3)) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))))
   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(Cons(z0, z1), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, z1), Cons(Cons(Nil, Nil), 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(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, F_2, G_2

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


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

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

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

(200)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   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(Cons(z0, z1), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, z1), Cons(Cons(Nil, Nil), Cons(x2, x3))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))))
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, F_2, G_2, G[ITE][FALSE][ITE]_3

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


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

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

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

(202)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   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, x1), Cons(Cons(Nil, Nil), Cons(x2, x3))) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))))
   G(Cons(z0, z1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, z1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), 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(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, F_2, G[ITE][FALSE][ITE]_3, G_2

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


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

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

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

(204)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
Tuples:
   LT0(Cons(z0, z1), Cons(z2, z3)) -> c6(LT0(z1, z3))
   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(Cons(z0, z1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, z1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3))))))
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, F_2, G_2, G[ITE][FALSE][ITE]_3

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


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

(205) 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)))

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

(206)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
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)))
   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(Cons(z0, z1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, z1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3))))))
   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:   F_2, G_2, G[ITE][FALSE][ITE]_3, LT0_2

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


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

(207) 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)))

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

(208)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
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)))
   G(Cons(z0, z1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, z1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))), LT0(Cons(z0, z1), Cons(Nil, Nil)))
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3))))))
   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:   F_2, G_2, G[ITE][FALSE][ITE]_3, LT0_2

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


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

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

(210)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
Tuples:
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3))))))
   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(z0, z1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, z1), Cons(Cons(Nil, Nil), 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, F_2, G_2

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


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

(211) 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, x1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3))))))
   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(z0, z1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, z1), Cons(Cons(Nil, Nil), 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)) = x_1
   POL(LT0(x_1, x_2)) = x_1 + x_2
   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

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

(212)
Obligation:
Complexity Dependency Tuples Problem

Rules:none
Tuples:
   G[ITE][FALSE][ITE](False, Cons(x0, x1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))) -> c(G(x1, Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3))))))
   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(z0, z1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, z1), Cons(Cons(Nil, Nil), 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, F_2, G_2

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


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

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

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

(214)
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(z0, z1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, z1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z2, z3)))) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z2, z3))))))
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


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

(215) 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))))

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

(216)
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(Cons(z0, z1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, z1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z2, z3)))) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z2, z3))))))
   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_2, G[ITE][FALSE][ITE]_3, LT0_2

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


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

(217) 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)))

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

(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)), 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(z0, z1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, z1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z2, z3)))) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z2, z3))))))
   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_2, G[ITE][FALSE][ITE]_3, LT0_2

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


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

(219) 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)))

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

(220)
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(Cons(z0, z1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, z1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z2, z3)))) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z2, z3))))))
   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_2, G[ITE][FALSE][ITE]_3, LT0_2

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


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

(221) 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))))

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

(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(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(z0, z1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, z1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z2, z3)))) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z2, z3))))))
   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_2, G[ITE][FALSE][ITE]_3, LT0_2

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


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

(223) 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)))

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

(224)
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(Cons(z0, z1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, z1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z2, z3)))) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z2, z3))))))
   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_2, G[ITE][FALSE][ITE]_3, LT0_2

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


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

(225) 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))))

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

(226)
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(Cons(z0, z1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, z1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z2, z3)))) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z2, z3))))))
   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_2, G[ITE][FALSE][ITE]_3, LT0_2

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


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

(227) 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)))

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

(228)
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(Cons(z0, z1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, z1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z2, z3)))) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z2, z3))))))
   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_2, G[ITE][FALSE][ITE]_3, LT0_2

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


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

(229) 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)))))

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

(230)
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(Cons(z0, z1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, z1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x2, x3)))))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z2, z3)))) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z2, z3))))))
   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_2, G[ITE][FALSE][ITE]_3, LT0_2

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


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

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

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

(232)
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(z0, Cons(y0, y1)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z2, z3)))) -> c(G(Cons(y0, y1), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z2, z3))))))
   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(z2, z3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, Cons(y1, y2)), Cons(Cons(Nil, Nil), 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(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


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

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

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

(234)
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(z2, z3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z2, z3)))))
   G[ITE][FALSE][ITE](False, Cons(z0, Cons(z1, Cons(y1, y2))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z3, z4)))) -> c(G(Cons(z1, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z3, 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


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

(235) 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(z2, z3)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z2, z3))))) by 
   G(Cons(z0, Cons(z1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z3, z4)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, Cons(z1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z3, z4)))))

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

(236)
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), Cons(z3, z4)))) -> c(G(Cons(z1, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z3, z4))))))
   G(Cons(z0, Cons(z1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z3, z4)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, Cons(z1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z3, 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[ITE][FALSE][ITE]_3, G_2

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


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

(237) 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))))))

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

(238)
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[ITE][FALSE][ITE](False, Cons(z0, Cons(z1, Cons(y1, y2))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z3, z4)))) -> c(G(Cons(z1, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z3, z4))))))
   G(Cons(z0, Cons(z1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z3, z4)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, Cons(z1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z3, 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[ITE][FALSE][ITE]_3, G_2

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


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

(239) 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)))))))

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

(240)
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[ITE][FALSE][ITE](False, Cons(z0, Cons(z1, Cons(y1, y2))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z3, z4)))) -> c(G(Cons(z1, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z3, z4))))))
   G(Cons(z0, Cons(z1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z3, z4)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, Cons(z1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z3, 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[ITE][FALSE][ITE]_3, G_2

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


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

(241) 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))))))

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

(242)
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[ITE][FALSE][ITE](False, Cons(z0, Cons(z1, Cons(y1, y2))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z3, z4)))) -> c(G(Cons(z1, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z3, z4))))))
   G(Cons(z0, Cons(z1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z3, z4)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, Cons(z1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z3, 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[ITE][FALSE][ITE]_3, G_2

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


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

(243) 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)))))))

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

(244)
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[ITE][FALSE][ITE](False, Cons(z0, Cons(z1, Cons(y1, y2))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z3, z4)))) -> c(G(Cons(z1, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z3, z4))))))
   G(Cons(z0, Cons(z1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z3, z4)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, Cons(z1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z3, 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[ITE][FALSE][ITE]_3, G_2

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


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

(245) 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)))))))

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

(246)
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[ITE][FALSE][ITE](False, Cons(z0, Cons(z1, Cons(y1, y2))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z3, z4)))) -> c(G(Cons(z1, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z3, z4))))))
   G(Cons(z0, Cons(z1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z3, z4)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, Cons(z1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z3, 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[ITE][FALSE][ITE]_3, G_2

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


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

(247) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace F(Cons(z0, Cons(y0, y1)), Cons(z2, z3)) -> c12(F(Cons(y0, y1), Cons(y0, y1))) by 
   F(Cons(x0, Cons(z1, z2)), Cons(x0, Cons(z1, z2))) -> c12(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c12(F(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))) -> c12(F(Cons(x1, x2), Cons(x1, x2)))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c12(F(Cons(x3, x4), Cons(x3, x4)))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c12(F(Cons(x3, Cons(x4, x5)), Cons(x3, Cons(x4, x5))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c12(F(Cons(x3, x4), Cons(x3, x4)))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c12(F(Cons(x4, x5), Cons(x4, x5)))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c12(F(Cons(x3, Cons(x4, Cons(x5, x6))), Cons(x3, Cons(x4, Cons(x5, x6)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x3, x4))))
   F(Cons(x1, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c12(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c12(F(Cons(x2, Cons(x3, x4)), Cons(x2, Cons(x3, x4))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c12(F(Cons(x2, Cons(x3, Cons(x4, x5))), Cons(x2, Cons(x3, Cons(x4, x5)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c12(F(Cons(x2, x3), 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)))) -> c12(F(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)))) -> c12(F(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))))) -> c12(F(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))))) -> c12(F(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))))) -> c12(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, Cons(x2, x3))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))) -> c12(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(Cons(Nil, Nil), 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, x2))), Cons(x1, x2)) -> c12(F(Cons(x0, Cons(x1, x2)), Cons(x0, Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(x1, Cons(x2, x3))) -> c12(F(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(x0, Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(x0, x1)) -> c12(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)))) -> c12(F(Cons(x4, x5), Cons(x4, x5)))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(x1, Cons(x2, x3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(Cons(Nil, Nil), Cons(x4, x5))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x5, x6)), Cons(Cons(Nil, Nil), Cons(x5, x6))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x3, x4))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))), Cons(x1, x2)) -> c12(F(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(x0, x1))) -> c12(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))) -> c12(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)))) -> c12(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)))) -> 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(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)))) -> 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(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))))) -> 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(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))))) -> c12(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, z2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))) -> c12(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(x1, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(z1, z2))))) -> c12(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(x0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(z1, z2))))) -> c12(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6)))) -> c12(F(Cons(x2, Cons(x3, x4)), Cons(x2, Cons(x3, x4))))
   F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))) -> c12(F(Cons(x1, x2), Cons(x1, x2)))
   F(Cons(x1, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))) -> c12(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))) -> c12(F(Cons(x0, x1), Cons(x0, x1)))
   F(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))) -> c12(F(Cons(x1, Cons(x2, x3)), Cons(x1, Cons(x2, x3))))
   F(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)))))) -> c12(F(Cons(x0, Cons(x1, x2)), Cons(x0, Cons(x1, x2))))
   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)))))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), 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))))))) -> c12(F(Cons(x0, Cons(x1, Cons(x2, x3))), 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))))))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))
   F(Cons(x0, Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c12(F(Cons(x1, x2), Cons(x1, x2)))
   F(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))) -> c12(F(Cons(x1, Cons(x2, x3)), Cons(x1, Cons(x2, x3))))
   F(Cons(x0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x2, Cons(x3, Cons(x4, x5))))) -> c12(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(x2, Cons(x3, x4)))) -> c12(F(Cons(x0, x1), Cons(x0, x1)))
   F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(x2, Cons(x3, Cons(x4, x5))))) -> c12(F(Cons(x0, x1), Cons(x0, x1)))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c12(F(Cons(x0, Cons(x1, x2)), Cons(x0, Cons(x1, x2))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))))) -> c12(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3))))))) -> c12(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))))) -> c12(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))))) -> c12(F(Cons(x2, x3), Cons(x2, x3)))
   F(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))))))) -> c12(F(Cons(x1, x2), Cons(x1, x2)))
   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))))))) -> c12(F(Cons(x0, x1), Cons(x0, x1)))
   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)))))))) -> c12(F(Cons(x1, Cons(x2, x3)), Cons(x1, Cons(x2, x3))))
   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)))))))) -> c12(F(Cons(x0, Cons(x1, x2)), Cons(x0, Cons(x1, x2))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, Cons(x6, x7)))))) -> c12(F(Cons(x2, x3), Cons(x2, x3)))

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

(248)
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, 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), Cons(z3, z4)))) -> c(G(Cons(z1, Cons(y1, y2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z3, z4))))))
   G(Cons(z0, Cons(z1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z3, z4)))) -> c9(G[ITE][FALSE][ITE](False, Cons(z0, Cons(z1, Cons(y2, y3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(z3, 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)))))))
   F(Cons(x0, Cons(z1, z2)), Cons(x0, Cons(z1, z2))) -> c12(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c12(F(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))) -> c12(F(Cons(x1, x2), Cons(x1, x2)))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c12(F(Cons(x3, x4), Cons(x3, x4)))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c12(F(Cons(x3, Cons(x4, x5)), Cons(x3, Cons(x4, x5))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c12(F(Cons(x3, x4), Cons(x3, x4)))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c12(F(Cons(x4, x5), Cons(x4, x5)))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c12(F(Cons(x3, Cons(x4, Cons(x5, x6))), Cons(x3, Cons(x4, Cons(x5, x6)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x3, x4))))
   F(Cons(x1, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c12(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c12(F(Cons(x2, Cons(x3, x4)), Cons(x2, Cons(x3, x4))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c12(F(Cons(x2, Cons(x3, Cons(x4, x5))), Cons(x2, Cons(x3, Cons(x4, x5)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c12(F(Cons(x2, x3), 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)))) -> c12(F(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)))) -> c12(F(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))))) -> c12(F(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))))) -> c12(F(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))))) -> c12(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, Cons(x2, x3))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))) -> c12(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(Cons(Nil, Nil), 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, x2))), Cons(x1, x2)) -> c12(F(Cons(x0, Cons(x1, x2)), Cons(x0, Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(x1, Cons(x2, x3))) -> c12(F(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(x0, Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(x0, x1)) -> c12(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)))) -> c12(F(Cons(x4, x5), Cons(x4, x5)))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(x1, Cons(x2, x3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(Cons(Nil, Nil), Cons(x4, x5))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x5, x6)), Cons(Cons(Nil, Nil), Cons(x5, x6))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x3, x4))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))), Cons(x1, x2)) -> c12(F(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(x0, x1))) -> c12(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))) -> c12(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)))) -> c12(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)))) -> 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(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)))) -> 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(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))))) -> 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(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))))) -> c12(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, z2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))) -> c12(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(x1, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(z1, z2))))) -> c12(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(x0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(z1, z2))))) -> c12(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6)))) -> c12(F(Cons(x2, Cons(x3, x4)), Cons(x2, Cons(x3, x4))))
   F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))) -> c12(F(Cons(x1, x2), Cons(x1, x2)))
   F(Cons(x1, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))) -> c12(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))) -> c12(F(Cons(x0, x1), Cons(x0, x1)))
   F(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))) -> c12(F(Cons(x1, Cons(x2, x3)), Cons(x1, Cons(x2, x3))))
   F(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)))))) -> c12(F(Cons(x0, Cons(x1, x2)), Cons(x0, Cons(x1, x2))))
   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)))))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), 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))))))) -> c12(F(Cons(x0, Cons(x1, Cons(x2, x3))), 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))))))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))
   F(Cons(x0, Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c12(F(Cons(x1, x2), Cons(x1, x2)))
   F(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))) -> c12(F(Cons(x1, Cons(x2, x3)), Cons(x1, Cons(x2, x3))))
   F(Cons(x0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x2, Cons(x3, Cons(x4, x5))))) -> c12(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(x2, Cons(x3, x4)))) -> c12(F(Cons(x0, x1), Cons(x0, x1)))
   F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(x2, Cons(x3, Cons(x4, x5))))) -> c12(F(Cons(x0, x1), Cons(x0, x1)))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c12(F(Cons(x0, Cons(x1, x2)), Cons(x0, Cons(x1, x2))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))))) -> c12(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3))))))) -> c12(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))))) -> c12(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))))) -> c12(F(Cons(x2, x3), Cons(x2, x3)))
   F(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))))))) -> c12(F(Cons(x1, x2), Cons(x1, x2)))
   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))))))) -> c12(F(Cons(x0, x1), Cons(x0, x1)))
   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)))))))) -> c12(F(Cons(x1, Cons(x2, x3)), Cons(x1, Cons(x2, x3))))
   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)))))))) -> c12(F(Cons(x0, Cons(x1, x2)), Cons(x0, Cons(x1, x2))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, Cons(x6, x7)))))) -> c12(F(Cons(x2, x3), Cons(x2, x3)))
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, 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)))))))
   F(Cons(x0, Cons(z1, z2)), Cons(x0, Cons(z1, z2))) -> c12(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c12(F(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))) -> c12(F(Cons(x1, x2), Cons(x1, x2)))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(x1, x2)) -> c12(F(Cons(x3, x4), Cons(x3, x4)))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))), Cons(x1, x2)) -> c12(F(Cons(x3, Cons(x4, x5)), Cons(x3, Cons(x4, x5))))
   F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c12(F(Cons(x3, x4), Cons(x3, x4)))
   F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(x1, Cons(x2, x3))) -> c12(F(Cons(x4, x5), Cons(x4, x5)))
   F(Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, Cons(x5, x6)))), Cons(x1, x2)) -> c12(F(Cons(x3, Cons(x4, Cons(x5, x6))), Cons(x3, Cons(x4, Cons(x5, x6)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(x1, x2)) -> c12(F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x3, x4))))
   F(Cons(x1, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c12(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x5, x6))) -> c12(F(Cons(x2, Cons(x3, x4)), Cons(x2, Cons(x3, x4))))
   F(Cons(x1, Cons(x2, Cons(x3, Cons(x4, x5)))), Cons(Cons(Nil, Nil), Cons(x6, x7))) -> c12(F(Cons(x2, Cons(x3, Cons(x4, x5))), Cons(x2, Cons(x3, Cons(x4, x5)))))
   F(Cons(x1, Cons(Cons(Nil, Nil), Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x4, x5))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x2, x3))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))) -> c12(F(Cons(x2, x3), 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)))) -> c12(F(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)))) -> c12(F(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))))) -> c12(F(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))))) -> c12(F(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))))) -> c12(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, Cons(x2, x3))))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))) -> c12(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(Cons(Nil, Nil), 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, x2))), Cons(x1, x2)) -> c12(F(Cons(x0, Cons(x1, x2)), Cons(x0, Cons(x1, x2))))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))), Cons(x1, Cons(x2, x3))) -> c12(F(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(x0, Cons(x1, Cons(x2, x3)))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))), Cons(x0, x1)) -> c12(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)))) -> c12(F(Cons(x4, x5), Cons(x4, x5)))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))), Cons(x1, Cons(x2, x3))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x4, x5)), Cons(Cons(Nil, Nil), Cons(x4, x5))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6))), Cons(x1, Cons(x2, Cons(x3, x4)))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x5, x6)), Cons(Cons(Nil, Nil), Cons(x5, x6))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x3, x4)), Cons(Cons(Nil, Nil), Cons(x3, x4))))
   F(Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5)))), Cons(x1, x2)) -> c12(F(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(x0, x1))) -> c12(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))) -> c12(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)))) -> c12(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)))) -> 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(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)))) -> 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(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))))) -> 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(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))))) -> c12(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, z2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))) -> c12(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(x1, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(z1, z2))))) -> c12(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(x0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(z1, z2))))) -> c12(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(x1, Cons(x2, Cons(x3, x4))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x5, x6)))) -> c12(F(Cons(x2, Cons(x3, x4)), Cons(x2, Cons(x3, x4))))
   F(Cons(Cons(Nil, Nil), Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, x4)))) -> c12(F(Cons(x1, x2), Cons(x1, x2)))
   F(Cons(x1, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x3, Cons(x4, x5))))) -> c12(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, x1))))) -> c12(F(Cons(x0, x1), Cons(x0, x1)))
   F(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3)))))) -> c12(F(Cons(x1, Cons(x2, x3)), Cons(x1, Cons(x2, x3))))
   F(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)))))) -> c12(F(Cons(x0, Cons(x1, x2)), Cons(x0, Cons(x1, x2))))
   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)))))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x0, x1)), 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))))))) -> c12(F(Cons(x0, Cons(x1, Cons(x2, x3))), 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))))))) -> c12(F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2)))))
   F(Cons(x0, Cons(x1, x2)), Cons(Cons(Nil, Nil), Cons(x1, x2))) -> c12(F(Cons(x1, x2), Cons(x1, x2)))
   F(Cons(x0, Cons(x1, Cons(x2, x3))), Cons(Cons(Nil, Nil), Cons(x1, Cons(x2, x3)))) -> c12(F(Cons(x1, Cons(x2, x3)), Cons(x1, Cons(x2, x3))))
   F(Cons(x0, Cons(z1, z2)), Cons(Cons(Nil, Nil), Cons(x2, Cons(x3, Cons(x4, x5))))) -> c12(F(Cons(z1, z2), Cons(z1, z2)))
   F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(x2, Cons(x3, x4)))) -> c12(F(Cons(x0, x1), Cons(x0, x1)))
   F(Cons(Cons(Nil, Nil), Cons(x0, x1)), Cons(Cons(Nil, Nil), Cons(x2, Cons(x3, Cons(x4, x5))))) -> c12(F(Cons(x0, x1), Cons(x0, x1)))
   F(Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, x2))), Cons(Cons(Nil, Nil), Cons(x3, x4))) -> c12(F(Cons(x0, Cons(x1, x2)), Cons(x0, Cons(x1, x2))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, x5))))) -> c12(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x0, Cons(x1, Cons(x2, x3))))))) -> c12(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x0, Cons(x1, Cons(x2, x3))))))) -> c12(F(Cons(x2, x3), Cons(x2, x3)))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, x6)))))) -> c12(F(Cons(x2, x3), Cons(x2, x3)))
   F(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))))))) -> c12(F(Cons(x1, x2), Cons(x1, x2)))
   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))))))) -> c12(F(Cons(x0, x1), Cons(x0, x1)))
   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)))))))) -> c12(F(Cons(x1, Cons(x2, x3)), Cons(x1, Cons(x2, x3))))
   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)))))))) -> c12(F(Cons(x0, Cons(x1, x2)), Cons(x0, Cons(x1, x2))))
   F(Cons(x1, Cons(x2, x3)), Cons(Cons(Nil, Nil), Cons(Cons(Nil, Nil), Cons(x4, Cons(x5, Cons(x6, x7)))))) -> c12(F(Cons(x2, x3), 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:   LT0_2, F_2, G[ITE][FALSE][ITE]_3, G_2

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


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

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

(250)
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
----------------------------------------

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

(252)
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
----------------------------------------

(253) 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

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

(254)
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
----------------------------------------

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

(256)
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
----------------------------------------

(257) 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

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

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


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

(259) 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

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

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


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

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

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


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

(263) 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 }

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

(264)
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}

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

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

(266)
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}

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

(267) 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

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

(268)
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]

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

(269) 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

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

(270)
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]

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

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

(272)
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]

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

(273) 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

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

(274)
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]

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

(275) 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'

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

(276)
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]

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

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

(278)
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]

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

(279) 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''

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

(280)
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'']

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

(281) 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

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

(282)
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'']

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

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

(284)
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'']

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

(285) 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

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

(286)
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]

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

(287) 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

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

(288)
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]

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

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

(290)
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]

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

(291) 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

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

(292)
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]

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

(293) 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: ?

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

(294)
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]

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

(295) 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

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

(296)
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
----------------------------------------

(297) 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

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

(298)
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.