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


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

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


The TRS R consists of the following rules:

   #less(@x, @y) -> #cklt(#compare(@x, @y))
   merge(@l1, @l2) -> merge#1(@l1, @l2)
   merge#1(::(@x, @xs), @l2) -> merge#2(@l2, @x, @xs)
   merge#1(nil, @l2) -> @l2
   merge#2(::(@y, @ys), @x, @xs) -> merge#3(#less(@x, @y), @x, @xs, @y, @ys)
   merge#2(nil, @x, @xs) -> ::(@x, @xs)
   merge#3(#false, @x, @xs, @y, @ys) -> ::(@y, merge(::(@x, @xs), @ys))
   merge#3(#true, @x, @xs, @y, @ys) -> ::(@x, merge(@xs, ::(@y, @ys)))
   mergesort(@l) -> mergesort#1(@l)
   mergesort#1(::(@x1, @xs)) -> mergesort#2(@xs, @x1)
   mergesort#1(nil) -> nil
   mergesort#2(::(@x2, @xs'), @x1) -> mergesort#3(msplit(::(@x1, ::(@x2, @xs'))))
   mergesort#2(nil, @x1) -> ::(@x1, nil)
   mergesort#3(tuple#2(@l1, @l2)) -> merge(mergesort(@l1), mergesort(@l2))
   msplit(@l) -> msplit#1(@l)
   msplit#1(::(@x1, @xs)) -> msplit#2(@xs, @x1)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(@x2, @xs'), @x1) -> msplit#3(msplit(@xs'), @x1, @x2)
   msplit#2(nil, @x1) -> tuple#2(::(@x1, nil), nil)
   msplit#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2))

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

   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(@y)) -> #GT
   #compare(#0, #pos(@y)) -> #LT
   #compare(#0, #s(@y)) -> #LT
   #compare(#neg(@x), #0) -> #LT
   #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
   #compare(#neg(@x), #pos(@y)) -> #LT
   #compare(#pos(@x), #0) -> #GT
   #compare(#pos(@x), #neg(@y)) -> #GT
   #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
   #compare(#s(@x), #0) -> #GT
   #compare(#s(@x), #s(@y)) -> #compare(@x, @y)

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:

   #less(@x, @y) -> #cklt(#compare(@x, @y))
   merge(@l1, @l2) -> merge#1(@l1, @l2)
   merge#1(::(@x, @xs), @l2) -> merge#2(@l2, @x, @xs)
   merge#1(nil, @l2) -> @l2
   merge#2(::(@y, @ys), @x, @xs) -> merge#3(#less(@x, @y), @x, @xs, @y, @ys)
   merge#2(nil, @x, @xs) -> ::(@x, @xs)
   merge#3(#false, @x, @xs, @y, @ys) -> ::(@y, merge(::(@x, @xs), @ys))
   merge#3(#true, @x, @xs, @y, @ys) -> ::(@x, merge(@xs, ::(@y, @ys)))
   mergesort(@l) -> mergesort#1(@l)
   mergesort#1(::(@x1, @xs)) -> mergesort#2(@xs, @x1)
   mergesort#1(nil) -> nil
   mergesort#2(::(@x2, @xs'), @x1) -> mergesort#3(msplit(::(@x1, ::(@x2, @xs'))))
   mergesort#2(nil, @x1) -> ::(@x1, nil)
   mergesort#3(tuple#2(@l1, @l2)) -> merge(mergesort(@l1), mergesort(@l2))
   msplit(@l) -> msplit#1(@l)
   msplit#1(::(@x1, @xs)) -> msplit#2(@xs, @x1)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(@x2, @xs'), @x1) -> msplit#3(msplit(@xs'), @x1, @x2)
   msplit#2(nil, @x1) -> tuple#2(::(@x1, nil), nil)
   msplit#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2))

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

   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(@y)) -> #GT
   #compare(#0, #pos(@y)) -> #LT
   #compare(#0, #s(@y)) -> #LT
   #compare(#neg(@x), #0) -> #LT
   #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
   #compare(#neg(@x), #pos(@y)) -> #LT
   #compare(#pos(@x), #0) -> #GT
   #compare(#pos(@x), #neg(@y)) -> #GT
   #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
   #compare(#s(@x), #0) -> #GT
   #compare(#s(@x), #s(@y)) -> #compare(@x, @y)

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:

   #less(@x, @y) -> #cklt(#compare(@x, @y))
   merge(@l1, @l2) -> merge#1(@l1, @l2)
   merge#1(::(@x, @xs), @l2) -> merge#2(@l2, @x, @xs)
   merge#1(nil, @l2) -> @l2
   merge#2(::(@y, @ys), @x, @xs) -> merge#3(#less(@x, @y), @x, @xs, @y, @ys)
   merge#2(nil, @x, @xs) -> ::(@x, @xs)
   merge#3(#false, @x, @xs, @y, @ys) -> ::(@y, merge(::(@x, @xs), @ys))
   merge#3(#true, @x, @xs, @y, @ys) -> ::(@x, merge(@xs, ::(@y, @ys)))
   mergesort(@l) -> mergesort#1(@l)
   mergesort#1(::(@x1, @xs)) -> mergesort#2(@xs, @x1)
   mergesort#1(nil) -> nil
   mergesort#2(::(@x2, @xs'), @x1) -> mergesort#3(msplit(::(@x1, ::(@x2, @xs'))))
   mergesort#2(nil, @x1) -> ::(@x1, nil)
   mergesort#3(tuple#2(@l1, @l2)) -> merge(mergesort(@l1), mergesort(@l2))
   msplit(@l) -> msplit#1(@l)
   msplit#1(::(@x1, @xs)) -> msplit#2(@xs, @x1)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(@x2, @xs'), @x1) -> msplit#3(msplit(@xs'), @x1, @x2)
   msplit#2(nil, @x1) -> tuple#2(::(@x1, nil), nil)
   msplit#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2))

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

   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(@y)) -> #GT
   #compare(#0, #pos(@y)) -> #LT
   #compare(#0, #s(@y)) -> #LT
   #compare(#neg(@x), #0) -> #LT
   #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
   #compare(#neg(@x), #pos(@y)) -> #LT
   #compare(#pos(@x), #0) -> #GT
   #compare(#pos(@x), #neg(@y)) -> #GT
   #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
   #compare(#s(@x), #0) -> #GT
   #compare(#s(@x), #s(@y)) -> #compare(@x, @y)

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:

   #less(@x, @y) -> #cklt(#compare(@x, @y))
   merge(@l1, @l2) -> merge#1(@l1, @l2)
   merge#1(::(@x, @xs), @l2) -> merge#2(@l2, @x, @xs)
   merge#1(nil, @l2) -> @l2
   merge#2(::(@y, @ys), @x, @xs) -> merge#3(#less(@x, @y), @x, @xs, @y, @ys)
   merge#2(nil, @x, @xs) -> ::(@x, @xs)
   merge#3(#false, @x, @xs, @y, @ys) -> ::(@y, merge(::(@x, @xs), @ys))
   merge#3(#true, @x, @xs, @y, @ys) -> ::(@x, merge(@xs, ::(@y, @ys)))
   mergesort(@l) -> mergesort#1(@l)
   mergesort#1(::(@x1, @xs)) -> mergesort#2(@xs, @x1)
   mergesort#1(nil) -> nil
   mergesort#2(::(@x2, @xs'), @x1) -> mergesort#3(msplit(::(@x1, ::(@x2, @xs'))))
   mergesort#2(nil, @x1) -> ::(@x1, nil)
   mergesort#3(tuple#2(@l1, @l2)) -> merge(mergesort(@l1), mergesort(@l2))
   msplit(@l) -> msplit#1(@l)
   msplit#1(::(@x1, @xs)) -> msplit#2(@xs, @x1)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(@x2, @xs'), @x1) -> msplit#3(msplit(@xs'), @x1, @x2)
   msplit#2(nil, @x1) -> tuple#2(::(@x1, nil), nil)
   msplit#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2))
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(@y)) -> #GT
   #compare(#0, #pos(@y)) -> #LT
   #compare(#0, #s(@y)) -> #LT
   #compare(#neg(@x), #0) -> #LT
   #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x)
   #compare(#neg(@x), #pos(@y)) -> #LT
   #compare(#pos(@x), #0) -> #GT
   #compare(#pos(@x), #neg(@y)) -> #GT
   #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y)
   #compare(#s(@x), #0) -> #GT
   #compare(#s(@x), #s(@y)) -> #compare(@x, @y)

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

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

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


The TRS R consists of the following rules:

   #less(@x, @y) -> #cklt(#compare(@x, @y)) [1]
   merge(@l1, @l2) -> merge#1(@l1, @l2) [1]
   merge#1(::(@x, @xs), @l2) -> merge#2(@l2, @x, @xs) [1]
   merge#1(nil, @l2) -> @l2 [1]
   merge#2(::(@y, @ys), @x, @xs) -> merge#3(#less(@x, @y), @x, @xs, @y, @ys) [1]
   merge#2(nil, @x, @xs) -> ::(@x, @xs) [1]
   merge#3(#false, @x, @xs, @y, @ys) -> ::(@y, merge(::(@x, @xs), @ys)) [1]
   merge#3(#true, @x, @xs, @y, @ys) -> ::(@x, merge(@xs, ::(@y, @ys))) [1]
   mergesort(@l) -> mergesort#1(@l) [1]
   mergesort#1(::(@x1, @xs)) -> mergesort#2(@xs, @x1) [1]
   mergesort#1(nil) -> nil [1]
   mergesort#2(::(@x2, @xs'), @x1) -> mergesort#3(msplit(::(@x1, ::(@x2, @xs')))) [1]
   mergesort#2(nil, @x1) -> ::(@x1, nil) [1]
   mergesort#3(tuple#2(@l1, @l2)) -> merge(mergesort(@l1), mergesort(@l2)) [1]
   msplit(@l) -> msplit#1(@l) [1]
   msplit#1(::(@x1, @xs)) -> msplit#2(@xs, @x1) [1]
   msplit#1(nil) -> tuple#2(nil, nil) [1]
   msplit#2(::(@x2, @xs'), @x1) -> msplit#3(msplit(@xs'), @x1, @x2) [1]
   msplit#2(nil, @x1) -> tuple#2(::(@x1, nil), nil) [1]
   msplit#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) [1]
   #cklt(#EQ) -> #false [0]
   #cklt(#GT) -> #false [0]
   #cklt(#LT) -> #true [0]
   #compare(#0, #0) -> #EQ [0]
   #compare(#0, #neg(@y)) -> #GT [0]
   #compare(#0, #pos(@y)) -> #LT [0]
   #compare(#0, #s(@y)) -> #LT [0]
   #compare(#neg(@x), #0) -> #LT [0]
   #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x) [0]
   #compare(#neg(@x), #pos(@y)) -> #LT [0]
   #compare(#pos(@x), #0) -> #GT [0]
   #compare(#pos(@x), #neg(@y)) -> #GT [0]
   #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y) [0]
   #compare(#s(@x), #0) -> #GT [0]
   #compare(#s(@x), #s(@y)) -> #compare(@x, @y) [0]

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

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

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

   #less(@x, @y) -> #cklt(#compare(@x, @y)) [1]
   merge(@l1, @l2) -> merge#1(@l1, @l2) [1]
   merge#1(::(@x, @xs), @l2) -> merge#2(@l2, @x, @xs) [1]
   merge#1(nil, @l2) -> @l2 [1]
   merge#2(::(@y, @ys), @x, @xs) -> merge#3(#less(@x, @y), @x, @xs, @y, @ys) [1]
   merge#2(nil, @x, @xs) -> ::(@x, @xs) [1]
   merge#3(#false, @x, @xs, @y, @ys) -> ::(@y, merge(::(@x, @xs), @ys)) [1]
   merge#3(#true, @x, @xs, @y, @ys) -> ::(@x, merge(@xs, ::(@y, @ys))) [1]
   mergesort(@l) -> mergesort#1(@l) [1]
   mergesort#1(::(@x1, @xs)) -> mergesort#2(@xs, @x1) [1]
   mergesort#1(nil) -> nil [1]
   mergesort#2(::(@x2, @xs'), @x1) -> mergesort#3(msplit(::(@x1, ::(@x2, @xs')))) [1]
   mergesort#2(nil, @x1) -> ::(@x1, nil) [1]
   mergesort#3(tuple#2(@l1, @l2)) -> merge(mergesort(@l1), mergesort(@l2)) [1]
   msplit(@l) -> msplit#1(@l) [1]
   msplit#1(::(@x1, @xs)) -> msplit#2(@xs, @x1) [1]
   msplit#1(nil) -> tuple#2(nil, nil) [1]
   msplit#2(::(@x2, @xs'), @x1) -> msplit#3(msplit(@xs'), @x1, @x2) [1]
   msplit#2(nil, @x1) -> tuple#2(::(@x1, nil), nil) [1]
   msplit#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) [1]
   #cklt(#EQ) -> #false [0]
   #cklt(#GT) -> #false [0]
   #cklt(#LT) -> #true [0]
   #compare(#0, #0) -> #EQ [0]
   #compare(#0, #neg(@y)) -> #GT [0]
   #compare(#0, #pos(@y)) -> #LT [0]
   #compare(#0, #s(@y)) -> #LT [0]
   #compare(#neg(@x), #0) -> #LT [0]
   #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x) [0]
   #compare(#neg(@x), #pos(@y)) -> #LT [0]
   #compare(#pos(@x), #0) -> #GT [0]
   #compare(#pos(@x), #neg(@y)) -> #GT [0]
   #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y) [0]
   #compare(#s(@x), #0) -> #GT [0]
   #compare(#s(@x), #s(@y)) -> #compare(@x, @y) [0]

The TRS has the following type information:
#less :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #false:#true
#cklt :: #EQ:#GT:#LT -> #false:#true
#compare :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #EQ:#GT:#LT
merge :: :::nil -> :::nil -> :::nil
merge#1 :: :::nil -> :::nil -> :::nil
:: :: #0:#neg:#pos:#s -> :::nil -> :::nil
merge#2 :: :::nil -> #0:#neg:#pos:#s -> :::nil -> :::nil
nil :: :::nil
merge#3 :: #false:#true -> #0:#neg:#pos:#s -> :::nil -> #0:#neg:#pos:#s -> :::nil -> :::nil
#false :: #false:#true
#true :: #false:#true
mergesort :: :::nil -> :::nil
mergesort#1 :: :::nil -> :::nil
mergesort#2 :: :::nil -> #0:#neg:#pos:#s -> :::nil
mergesort#3 :: tuple#2 -> :::nil
msplit :: :::nil -> tuple#2
tuple#2 :: :::nil -> :::nil -> tuple#2
msplit#1 :: :::nil -> tuple#2
msplit#2 :: :::nil -> #0:#neg:#pos:#s -> tuple#2
msplit#3 :: tuple#2 -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2
#EQ :: #EQ:#GT:#LT
#GT :: #EQ:#GT:#LT
#LT :: #EQ:#GT:#LT
#0 :: #0:#neg:#pos:#s
#neg :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#pos :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#s :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s

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

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

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

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

(c) The following functions are completely defined:

   msplit_1
   mergesort_1
   #less_2
   msplit#1_1
   mergesort#1_1
   msplit#2_2
   mergesort#2_2
   mergesort#3_1
   merge_2
   msplit#3_3
   merge#1_2
   merge#2_3
   merge#3_5
   #cklt_1
   #compare_2

Due to the following rules being added:

   #cklt(v0) -> null_#cklt [0]
   #compare(v0, v1) -> null_#compare [0]
   mergesort#3(v0) -> nil [0]
   msplit#3(v0, v1, v2) -> const [0]
   merge#3(v0, v1, v2, v3, v4) -> nil [0]

And the following fresh constants:    null_#cklt, null_#compare, const

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

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

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

   #less(@x, @y) -> #cklt(#compare(@x, @y)) [1]
   merge(@l1, @l2) -> merge#1(@l1, @l2) [1]
   merge#1(::(@x, @xs), @l2) -> merge#2(@l2, @x, @xs) [1]
   merge#1(nil, @l2) -> @l2 [1]
   merge#2(::(@y, @ys), @x, @xs) -> merge#3(#less(@x, @y), @x, @xs, @y, @ys) [1]
   merge#2(nil, @x, @xs) -> ::(@x, @xs) [1]
   merge#3(#false, @x, @xs, @y, @ys) -> ::(@y, merge(::(@x, @xs), @ys)) [1]
   merge#3(#true, @x, @xs, @y, @ys) -> ::(@x, merge(@xs, ::(@y, @ys))) [1]
   mergesort(@l) -> mergesort#1(@l) [1]
   mergesort#1(::(@x1, @xs)) -> mergesort#2(@xs, @x1) [1]
   mergesort#1(nil) -> nil [1]
   mergesort#2(::(@x2, @xs'), @x1) -> mergesort#3(msplit(::(@x1, ::(@x2, @xs')))) [1]
   mergesort#2(nil, @x1) -> ::(@x1, nil) [1]
   mergesort#3(tuple#2(@l1, @l2)) -> merge(mergesort(@l1), mergesort(@l2)) [1]
   msplit(@l) -> msplit#1(@l) [1]
   msplit#1(::(@x1, @xs)) -> msplit#2(@xs, @x1) [1]
   msplit#1(nil) -> tuple#2(nil, nil) [1]
   msplit#2(::(@x2, @xs'), @x1) -> msplit#3(msplit(@xs'), @x1, @x2) [1]
   msplit#2(nil, @x1) -> tuple#2(::(@x1, nil), nil) [1]
   msplit#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) [1]
   #cklt(#EQ) -> #false [0]
   #cklt(#GT) -> #false [0]
   #cklt(#LT) -> #true [0]
   #compare(#0, #0) -> #EQ [0]
   #compare(#0, #neg(@y)) -> #GT [0]
   #compare(#0, #pos(@y)) -> #LT [0]
   #compare(#0, #s(@y)) -> #LT [0]
   #compare(#neg(@x), #0) -> #LT [0]
   #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x) [0]
   #compare(#neg(@x), #pos(@y)) -> #LT [0]
   #compare(#pos(@x), #0) -> #GT [0]
   #compare(#pos(@x), #neg(@y)) -> #GT [0]
   #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y) [0]
   #compare(#s(@x), #0) -> #GT [0]
   #compare(#s(@x), #s(@y)) -> #compare(@x, @y) [0]
   #cklt(v0) -> null_#cklt [0]
   #compare(v0, v1) -> null_#compare [0]
   mergesort#3(v0) -> nil [0]
   msplit#3(v0, v1, v2) -> const [0]
   merge#3(v0, v1, v2, v3, v4) -> nil [0]

The TRS has the following type information:
#less :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #false:#true:null_#cklt
#cklt :: #EQ:#GT:#LT:null_#compare -> #false:#true:null_#cklt
#compare :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #EQ:#GT:#LT:null_#compare
merge :: :::nil -> :::nil -> :::nil
merge#1 :: :::nil -> :::nil -> :::nil
:: :: #0:#neg:#pos:#s -> :::nil -> :::nil
merge#2 :: :::nil -> #0:#neg:#pos:#s -> :::nil -> :::nil
nil :: :::nil
merge#3 :: #false:#true:null_#cklt -> #0:#neg:#pos:#s -> :::nil -> #0:#neg:#pos:#s -> :::nil -> :::nil
#false :: #false:#true:null_#cklt
#true :: #false:#true:null_#cklt
mergesort :: :::nil -> :::nil
mergesort#1 :: :::nil -> :::nil
mergesort#2 :: :::nil -> #0:#neg:#pos:#s -> :::nil
mergesort#3 :: tuple#2:const -> :::nil
msplit :: :::nil -> tuple#2:const
tuple#2 :: :::nil -> :::nil -> tuple#2:const
msplit#1 :: :::nil -> tuple#2:const
msplit#2 :: :::nil -> #0:#neg:#pos:#s -> tuple#2:const
msplit#3 :: tuple#2:const -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2:const
#EQ :: #EQ:#GT:#LT:null_#compare
#GT :: #EQ:#GT:#LT:null_#compare
#LT :: #EQ:#GT:#LT:null_#compare
#0 :: #0:#neg:#pos:#s
#neg :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#pos :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#s :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
null_#cklt :: #false:#true:null_#cklt
null_#compare :: #EQ:#GT:#LT:null_#compare
const :: tuple#2:const

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

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

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

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

   #less(#0, #0) -> #cklt(#EQ) [1]
   #less(#0, #neg(@y')) -> #cklt(#GT) [1]
   #less(#0, #pos(@y'')) -> #cklt(#LT) [1]
   #less(#0, #s(@y1)) -> #cklt(#LT) [1]
   #less(#neg(@x'), #0) -> #cklt(#LT) [1]
   #less(#neg(@x''), #neg(@y2)) -> #cklt(#compare(@y2, @x'')) [1]
   #less(#neg(@x3), #pos(@y3)) -> #cklt(#LT) [1]
   #less(#pos(@x4), #0) -> #cklt(#GT) [1]
   #less(#pos(@x5), #neg(@y4)) -> #cklt(#GT) [1]
   #less(#pos(@x6), #pos(@y5)) -> #cklt(#compare(@x6, @y5)) [1]
   #less(#s(@x7), #0) -> #cklt(#GT) [1]
   #less(#s(@x8), #s(@y6)) -> #cklt(#compare(@x8, @y6)) [1]
   #less(@x, @y) -> #cklt(null_#compare) [1]
   merge(@l1, @l2) -> merge#1(@l1, @l2) [1]
   merge#1(::(@x, @xs), @l2) -> merge#2(@l2, @x, @xs) [1]
   merge#1(nil, @l2) -> @l2 [1]
   merge#2(::(@y, @ys), @x, @xs) -> merge#3(#cklt(#compare(@x, @y)), @x, @xs, @y, @ys) [2]
   merge#2(nil, @x, @xs) -> ::(@x, @xs) [1]
   merge#3(#false, @x, @xs, @y, @ys) -> ::(@y, merge(::(@x, @xs), @ys)) [1]
   merge#3(#true, @x, @xs, @y, @ys) -> ::(@x, merge(@xs, ::(@y, @ys))) [1]
   mergesort(@l) -> mergesort#1(@l) [1]
   mergesort#1(::(@x1, @xs)) -> mergesort#2(@xs, @x1) [1]
   mergesort#1(nil) -> nil [1]
   mergesort#2(::(@x2, @xs'), @x1) -> mergesort#3(msplit#1(::(@x1, ::(@x2, @xs')))) [2]
   mergesort#2(nil, @x1) -> ::(@x1, nil) [1]
   mergesort#3(tuple#2(@l1, @l2)) -> merge(mergesort#1(@l1), mergesort#1(@l2)) [3]
   msplit(@l) -> msplit#1(@l) [1]
   msplit#1(::(@x1, @xs)) -> msplit#2(@xs, @x1) [1]
   msplit#1(nil) -> tuple#2(nil, nil) [1]
   msplit#2(::(@x2, @xs'), @x1) -> msplit#3(msplit#1(@xs'), @x1, @x2) [2]
   msplit#2(nil, @x1) -> tuple#2(::(@x1, nil), nil) [1]
   msplit#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) [1]
   #cklt(#EQ) -> #false [0]
   #cklt(#GT) -> #false [0]
   #cklt(#LT) -> #true [0]
   #compare(#0, #0) -> #EQ [0]
   #compare(#0, #neg(@y)) -> #GT [0]
   #compare(#0, #pos(@y)) -> #LT [0]
   #compare(#0, #s(@y)) -> #LT [0]
   #compare(#neg(@x), #0) -> #LT [0]
   #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x) [0]
   #compare(#neg(@x), #pos(@y)) -> #LT [0]
   #compare(#pos(@x), #0) -> #GT [0]
   #compare(#pos(@x), #neg(@y)) -> #GT [0]
   #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y) [0]
   #compare(#s(@x), #0) -> #GT [0]
   #compare(#s(@x), #s(@y)) -> #compare(@x, @y) [0]
   #cklt(v0) -> null_#cklt [0]
   #compare(v0, v1) -> null_#compare [0]
   mergesort#3(v0) -> nil [0]
   msplit#3(v0, v1, v2) -> const [0]
   merge#3(v0, v1, v2, v3, v4) -> nil [0]

The TRS has the following type information:
#less :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #false:#true:null_#cklt
#cklt :: #EQ:#GT:#LT:null_#compare -> #false:#true:null_#cklt
#compare :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #EQ:#GT:#LT:null_#compare
merge :: :::nil -> :::nil -> :::nil
merge#1 :: :::nil -> :::nil -> :::nil
:: :: #0:#neg:#pos:#s -> :::nil -> :::nil
merge#2 :: :::nil -> #0:#neg:#pos:#s -> :::nil -> :::nil
nil :: :::nil
merge#3 :: #false:#true:null_#cklt -> #0:#neg:#pos:#s -> :::nil -> #0:#neg:#pos:#s -> :::nil -> :::nil
#false :: #false:#true:null_#cklt
#true :: #false:#true:null_#cklt
mergesort :: :::nil -> :::nil
mergesort#1 :: :::nil -> :::nil
mergesort#2 :: :::nil -> #0:#neg:#pos:#s -> :::nil
mergesort#3 :: tuple#2:const -> :::nil
msplit :: :::nil -> tuple#2:const
tuple#2 :: :::nil -> :::nil -> tuple#2:const
msplit#1 :: :::nil -> tuple#2:const
msplit#2 :: :::nil -> #0:#neg:#pos:#s -> tuple#2:const
msplit#3 :: tuple#2:const -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2:const
#EQ :: #EQ:#GT:#LT:null_#compare
#GT :: #EQ:#GT:#LT:null_#compare
#LT :: #EQ:#GT:#LT:null_#compare
#0 :: #0:#neg:#pos:#s
#neg :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#pos :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#s :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
null_#cklt :: #false:#true:null_#cklt
null_#compare :: #EQ:#GT:#LT:null_#compare
const :: tuple#2:const

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

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

   nil => 0
   #false => 1
   #true => 2
   #EQ => 1
   #GT => 2
   #LT => 3
   #0 => 0
   null_#cklt => 0
   null_#compare => 0
   const => 0

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

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

   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' = 1 + @y, @y >= 0
   #compare(z, z') -{ 0 }-> 3 :|: @x >= 0, z = 1 + @x, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' = 1 + @y, @y >= 0
   #compare(z, z') -{ 0 }-> 2 :|: @x >= 0, z = 1 + @x, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   #compare(z, z') -{ 0 }-> #compare(@x, @y) :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0
   #compare(z, z') -{ 0 }-> #compare(@y, @x) :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0
   #less(z, z') -{ 1 }-> #cklt(3) :|: z' = 1 + @y'', @y'' >= 0, z = 0
   #less(z, z') -{ 1 }-> #cklt(3) :|: z' = 1 + @y1, @y1 >= 0, z = 0
   #less(z, z') -{ 1 }-> #cklt(3) :|: z = 1 + @x', @x' >= 0, z' = 0
   #less(z, z') -{ 1 }-> #cklt(3) :|: @y3 >= 0, @x3 >= 0, z' = 1 + @y3, z = 1 + @x3
   #less(z, z') -{ 1 }-> #cklt(2) :|: @y' >= 0, z' = 1 + @y', z = 0
   #less(z, z') -{ 1 }-> #cklt(2) :|: z = 1 + @x4, @x4 >= 0, z' = 0
   #less(z, z') -{ 1 }-> #cklt(2) :|: z = 1 + @x5, z' = 1 + @y4, @y4 >= 0, @x5 >= 0
   #less(z, z') -{ 1 }-> #cklt(2) :|: z = 1 + @x7, @x7 >= 0, z' = 0
   #less(z, z') -{ 1 }-> #cklt(1) :|: z = 0, z' = 0
   #less(z, z') -{ 1 }-> #cklt(0) :|: z = @x, @x >= 0, z' = @y, @y >= 0
   #less(z, z') -{ 1 }-> #cklt(#compare(@x6, @y5)) :|: z = 1 + @x6, z' = 1 + @y5, @y5 >= 0, @x6 >= 0
   #less(z, z') -{ 1 }-> #cklt(#compare(@x8, @y6)) :|: z = 1 + @x8, @x8 >= 0, z' = 1 + @y6, @y6 >= 0
   #less(z, z') -{ 1 }-> #cklt(#compare(@y2, @x'')) :|: z = 1 + @x'', z' = 1 + @y2, @y2 >= 0, @x'' >= 0
   merge(z, z') -{ 1 }-> merge#1(@l1, @l2) :|: @l1 >= 0, z' = @l2, @l2 >= 0, z = @l1
   merge#1(z, z') -{ 1 }-> @l2 :|: z' = @l2, @l2 >= 0, z = 0
   merge#1(z, z') -{ 1 }-> merge#2(@l2, @x, @xs) :|: z' = @l2, @x >= 0, z = 1 + @x + @xs, @l2 >= 0, @xs >= 0
   merge#2(z, z', z'') -{ 2 }-> merge#3(#cklt(#compare(@x, @y)), @x, @xs, @y, @ys) :|: z = 1 + @y + @ys, @x >= 0, @xs >= 0, @y >= 0, z' = @x, z'' = @xs, @ys >= 0
   merge#2(z, z', z'') -{ 1 }-> 1 + @x + @xs :|: @x >= 0, @xs >= 0, z = 0, z' = @x, z'' = @xs
   merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z1 = v3, v0 >= 0, v4 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, z2 = v4, v2 >= 0, v3 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + @x + merge(@xs, 1 + @y + @ys) :|: z = 2, @x >= 0, z1 = @y, @xs >= 0, z2 = @ys, @y >= 0, z' = @x, z'' = @xs, @ys >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + @y + merge(1 + @x + @xs, @ys) :|: @x >= 0, z = 1, z1 = @y, @xs >= 0, z2 = @ys, @y >= 0, z' = @x, z'' = @xs, @ys >= 0
   mergesort(z) -{ 1 }-> mergesort#1(@l) :|: z = @l, @l >= 0
   mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   mergesort#1(z) -{ 1 }-> 0 :|: z = 0
   mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + @x1 + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', z' = @x1, @xs' >= 0, @x1 >= 0, @x2 >= 0
   mergesort#2(z, z') -{ 1 }-> 1 + @x1 + 0 :|: z' = @x1, @x1 >= 0, z = 0
   mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0
   mergesort#3(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   msplit(z) -{ 1 }-> msplit#1(@l) :|: z = @l, @l >= 0
   msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0
   msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), @x1, @x2) :|: z = 1 + @x2 + @xs', z' = @x1, @xs' >= 0, @x1 >= 0, @x2 >= 0
   msplit#2(z, z') -{ 1 }-> 1 + (1 + @x1 + 0) + 0 :|: z' = @x1, @x1 >= 0, z = 0
   msplit#3(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + @x1 + @l1) + (1 + @x2 + @l2) :|: z' = @x1, @l1 >= 0, z = 1 + @l1 + @l2, z'' = @x2, @x1 >= 0, @l2 >= 0, @x2 >= 0


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

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

   msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + @x1 + @l1) + (1 + @x2 + @l2) :|: z' = @x1, @l1 >= 0, z = 1 + @l1 + @l2, z'' = @x2, @x1 >= 0, @l2 >= 0, @x2 >= 0
   msplit#3(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 2 :|: z = 3

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

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

   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' = 1 + @y, @y >= 0
   #compare(z, z') -{ 0 }-> 3 :|: @x >= 0, z = 1 + @x, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' = 1 + @y, @y >= 0
   #compare(z, z') -{ 0 }-> 2 :|: @x >= 0, z = 1 + @x, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   #compare(z, z') -{ 0 }-> #compare(@x, @y) :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0
   #compare(z, z') -{ 0 }-> #compare(@y, @x) :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0
   #less(z, z') -{ 1 }-> 2 :|: z' = 1 + @y'', @y'' >= 0, z = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z' = 1 + @y1, @y1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z = 1 + @x', @x' >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: @y3 >= 0, @x3 >= 0, z' = 1 + @y3, z = 1 + @x3, 3 = 3
   #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 1 }-> 1 :|: @y' >= 0, z' = 1 + @y', z = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z = 1 + @x4, @x4 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z = 1 + @x5, z' = 1 + @y4, @y4 >= 0, @x5 >= 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z = 1 + @x7, @x7 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 1 }-> 0 :|: @y' >= 0, z' = 1 + @y', z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' = 1 + @y'', @y'' >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' = 1 + @y1, @y1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z = 1 + @x', @x' >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: @y3 >= 0, @x3 >= 0, z' = 1 + @y3, z = 1 + @x3, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z = 1 + @x4, @x4 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z = 1 + @x5, z' = 1 + @y4, @y4 >= 0, @x5 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z = 1 + @x7, @x7 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z = @x, @x >= 0, z' = @y, @y >= 0, v0 >= 0, 0 = v0
   #less(z, z') -{ 1 }-> #cklt(#compare(@x6, @y5)) :|: z = 1 + @x6, z' = 1 + @y5, @y5 >= 0, @x6 >= 0
   #less(z, z') -{ 1 }-> #cklt(#compare(@x8, @y6)) :|: z = 1 + @x8, @x8 >= 0, z' = 1 + @y6, @y6 >= 0
   #less(z, z') -{ 1 }-> #cklt(#compare(@y2, @x'')) :|: z = 1 + @x'', z' = 1 + @y2, @y2 >= 0, @x'' >= 0
   merge(z, z') -{ 1 }-> merge#1(@l1, @l2) :|: @l1 >= 0, z' = @l2, @l2 >= 0, z = @l1
   merge#1(z, z') -{ 1 }-> @l2 :|: z' = @l2, @l2 >= 0, z = 0
   merge#1(z, z') -{ 1 }-> merge#2(@l2, @x, @xs) :|: z' = @l2, @x >= 0, z = 1 + @x + @xs, @l2 >= 0, @xs >= 0
   merge#2(z, z', z'') -{ 2 }-> merge#3(#cklt(#compare(@x, @y)), @x, @xs, @y, @ys) :|: z = 1 + @y + @ys, @x >= 0, @xs >= 0, @y >= 0, z' = @x, z'' = @xs, @ys >= 0
   merge#2(z, z', z'') -{ 1 }-> 1 + @x + @xs :|: @x >= 0, @xs >= 0, z = 0, z' = @x, z'' = @xs
   merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z1 = v3, v0 >= 0, v4 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, z2 = v4, v2 >= 0, v3 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + @x + merge(@xs, 1 + @y + @ys) :|: z = 2, @x >= 0, z1 = @y, @xs >= 0, z2 = @ys, @y >= 0, z' = @x, z'' = @xs, @ys >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + @y + merge(1 + @x + @xs, @ys) :|: @x >= 0, z = 1, z1 = @y, @xs >= 0, z2 = @ys, @y >= 0, z' = @x, z'' = @xs, @ys >= 0
   mergesort(z) -{ 1 }-> mergesort#1(@l) :|: z = @l, @l >= 0
   mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   mergesort#1(z) -{ 1 }-> 0 :|: z = 0
   mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + @x1 + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', z' = @x1, @xs' >= 0, @x1 >= 0, @x2 >= 0
   mergesort#2(z, z') -{ 1 }-> 1 + @x1 + 0 :|: z' = @x1, @x1 >= 0, z = 0
   mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0
   mergesort#3(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   msplit(z) -{ 1 }-> msplit#1(@l) :|: z = @l, @l >= 0
   msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0
   msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), @x1, @x2) :|: z = 1 + @x2 + @xs', z' = @x1, @xs' >= 0, @x1 >= 0, @x2 >= 0
   msplit#2(z, z') -{ 1 }-> 1 + (1 + @x1 + 0) + 0 :|: z' = @x1, @x1 >= 0, z = 0
   msplit#3(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + @x1 + @l1) + (1 + @x2 + @l2) :|: z' = @x1, @l1 >= 0, z = 1 + @l1 + @l2, z'' = @x2, @x1 >= 0, @l2 >= 0, @x2 >= 0


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

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

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

   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #compare(z, z') -{ 0 }-> #compare(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> #compare(z' - 1, z - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   #less(z, z') -{ 1 }-> #cklt(#compare(z - 1, z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> #cklt(#compare(z' - 1, z - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0
   merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   merge#2(z, z', z'') -{ 2 }-> merge#3(#cklt(#compare(z', @y)), z', z'', @y, @ys) :|: z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0
   merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0
   merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0
   mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0
   mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   mergesort#1(z) -{ 1 }-> 0 :|: z = 0
   mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0
   mergesort#3(z) -{ 0 }-> 0 :|: z >= 0
   msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0
   msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0
   msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0
   msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0


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

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

   { #compare }
   { msplit#3 }
   { #cklt }
   { #less }
   { merge#1, merge#2, merge, merge#3 }
   { msplit#1, msplit#2 }
   { mergesort#3, mergesort#1, mergesort#2 }
   { msplit }
   { mergesort }

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

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

   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #compare(z, z') -{ 0 }-> #compare(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> #compare(z' - 1, z - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   #less(z, z') -{ 1 }-> #cklt(#compare(z - 1, z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> #cklt(#compare(z' - 1, z - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0
   merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   merge#2(z, z', z'') -{ 2 }-> merge#3(#cklt(#compare(z', @y)), z', z'', @y, @ys) :|: z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0
   merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0
   merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0
   mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0
   mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   mergesort#1(z) -{ 1 }-> 0 :|: z = 0
   mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0
   mergesort#3(z) -{ 0 }-> 0 :|: z >= 0
   msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0
   msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0
   msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0
   msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0

Function symbols to be analyzed: {#compare}, {msplit#3}, {#cklt}, {#less}, {merge#1,merge#2,merge,merge#3}, {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort}

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

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

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

   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #compare(z, z') -{ 0 }-> #compare(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> #compare(z' - 1, z - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   #less(z, z') -{ 1 }-> #cklt(#compare(z - 1, z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> #cklt(#compare(z' - 1, z - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0
   merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   merge#2(z, z', z'') -{ 2 }-> merge#3(#cklt(#compare(z', @y)), z', z'', @y, @ys) :|: z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0
   merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0
   merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0
   mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0
   mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   mergesort#1(z) -{ 1 }-> 0 :|: z = 0
   mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0
   mergesort#3(z) -{ 0 }-> 0 :|: z >= 0
   msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0
   msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0
   msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0
   msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0

Function symbols to be analyzed: {#compare}, {msplit#3}, {#cklt}, {#less}, {merge#1,merge#2,merge,merge#3}, {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort}

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

(25) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #compare(z, z') -{ 0 }-> #compare(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> #compare(z' - 1, z - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   #less(z, z') -{ 1 }-> #cklt(#compare(z - 1, z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> #cklt(#compare(z' - 1, z - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0
   merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   merge#2(z, z', z'') -{ 2 }-> merge#3(#cklt(#compare(z', @y)), z', z'', @y, @ys) :|: z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0
   merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0
   merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0
   mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0
   mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   mergesort#1(z) -{ 1 }-> 0 :|: z = 0
   mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0
   mergesort#3(z) -{ 0 }-> 0 :|: z >= 0
   msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0
   msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0
   msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0
   msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0

Function symbols to be analyzed: {#compare}, {msplit#3}, {#cklt}, {#less}, {merge#1,merge#2,merge,merge#3}, {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort}
Previous analysis results are:
  #compare: runtime: ?, size: O(1) [3]

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

(27) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #compare(z, z') -{ 0 }-> #compare(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> #compare(z' - 1, z - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   #less(z, z') -{ 1 }-> #cklt(#compare(z - 1, z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> #cklt(#compare(z' - 1, z - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0
   merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   merge#2(z, z', z'') -{ 2 }-> merge#3(#cklt(#compare(z', @y)), z', z'', @y, @ys) :|: z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0
   merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0
   merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0
   mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0
   mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   mergesort#1(z) -{ 1 }-> 0 :|: z = 0
   mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0
   mergesort#3(z) -{ 0 }-> 0 :|: z >= 0
   msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0
   msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0
   msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0
   msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0

Function symbols to be analyzed: {msplit#3}, {#cklt}, {#less}, {merge#1,merge#2,merge,merge#3}, {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]

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

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

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

   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   #less(z, z') -{ 1 }-> #cklt(s'') :|: s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> #cklt(s1) :|: s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0
   merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0
   merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   merge#2(z, z', z'') -{ 2 }-> merge#3(#cklt(s2), z', z'', @y, @ys) :|: s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0
   merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0
   merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0
   mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0
   mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   mergesort#1(z) -{ 1 }-> 0 :|: z = 0
   mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0
   mergesort#3(z) -{ 0 }-> 0 :|: z >= 0
   msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0
   msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0
   msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0
   msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0

Function symbols to be analyzed: {msplit#3}, {#cklt}, {#less}, {merge#1,merge#2,merge,merge#3}, {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]

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

(31) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   #less(z, z') -{ 1 }-> #cklt(s'') :|: s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> #cklt(s1) :|: s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0
   merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0
   merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   merge#2(z, z', z'') -{ 2 }-> merge#3(#cklt(s2), z', z'', @y, @ys) :|: s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0
   merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0
   merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0
   mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0
   mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   mergesort#1(z) -{ 1 }-> 0 :|: z = 0
   mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0
   mergesort#3(z) -{ 0 }-> 0 :|: z >= 0
   msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0
   msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0
   msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0
   msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0

Function symbols to be analyzed: {msplit#3}, {#cklt}, {#less}, {merge#1,merge#2,merge,merge#3}, {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  msplit#3: runtime: ?, size: O(n^1) [2 + z + z' + z'']

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

(33) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   #less(z, z') -{ 1 }-> #cklt(s'') :|: s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> #cklt(s1) :|: s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0
   merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0
   merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   merge#2(z, z', z'') -{ 2 }-> merge#3(#cklt(s2), z', z'', @y, @ys) :|: s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0
   merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0
   merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0
   mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0
   mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   mergesort#1(z) -{ 1 }-> 0 :|: z = 0
   mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0
   mergesort#3(z) -{ 0 }-> 0 :|: z >= 0
   msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0
   msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0
   msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0
   msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0

Function symbols to be analyzed: {#cklt}, {#less}, {merge#1,merge#2,merge,merge#3}, {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  msplit#3: runtime: O(1) [1], size: O(n^1) [2 + z + z' + z'']

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

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

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

   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   #less(z, z') -{ 1 }-> #cklt(s'') :|: s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> #cklt(s1) :|: s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0
   merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0
   merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   merge#2(z, z', z'') -{ 2 }-> merge#3(#cklt(s2), z', z'', @y, @ys) :|: s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0
   merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0
   merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0
   mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0
   mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   mergesort#1(z) -{ 1 }-> 0 :|: z = 0
   mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0
   mergesort#3(z) -{ 0 }-> 0 :|: z >= 0
   msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0
   msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0
   msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0
   msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0

Function symbols to be analyzed: {#cklt}, {#less}, {merge#1,merge#2,merge,merge#3}, {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  msplit#3: runtime: O(1) [1], size: O(n^1) [2 + z + z' + z'']

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

(37) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   #less(z, z') -{ 1 }-> #cklt(s'') :|: s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> #cklt(s1) :|: s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0
   merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0
   merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   merge#2(z, z', z'') -{ 2 }-> merge#3(#cklt(s2), z', z'', @y, @ys) :|: s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0
   merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0
   merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0
   mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0
   mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   mergesort#1(z) -{ 1 }-> 0 :|: z = 0
   mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0
   mergesort#3(z) -{ 0 }-> 0 :|: z >= 0
   msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0
   msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0
   msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0
   msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0

Function symbols to be analyzed: {#cklt}, {#less}, {merge#1,merge#2,merge,merge#3}, {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  msplit#3: runtime: O(1) [1], size: O(n^1) [2 + z + z' + z'']
  #cklt: runtime: ?, size: O(1) [2]

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

(39) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   #less(z, z') -{ 1 }-> #cklt(s'') :|: s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> #cklt(s1) :|: s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0
   merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0
   merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   merge#2(z, z', z'') -{ 2 }-> merge#3(#cklt(s2), z', z'', @y, @ys) :|: s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0
   merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0
   merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0
   mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0
   mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   mergesort#1(z) -{ 1 }-> 0 :|: z = 0
   mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0
   mergesort#3(z) -{ 0 }-> 0 :|: z >= 0
   msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0
   msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0
   msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0
   msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0

Function symbols to be analyzed: {#less}, {merge#1,merge#2,merge,merge#3}, {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  msplit#3: runtime: O(1) [1], size: O(n^1) [2 + z + z' + z'']
  #cklt: runtime: O(1) [0], size: O(1) [2]

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

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

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

   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 1 }-> s3 :|: s3 >= 0, s3 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> s4 :|: s4 >= 0, s4 <= 2, s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0
   merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   merge#2(z, z', z'') -{ 2 }-> merge#3(s5, z', z'', @y, @ys) :|: s5 >= 0, s5 <= 2, s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0
   merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0
   merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0
   mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0
   mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   mergesort#1(z) -{ 1 }-> 0 :|: z = 0
   mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0
   mergesort#3(z) -{ 0 }-> 0 :|: z >= 0
   msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0
   msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0
   msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0
   msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0

Function symbols to be analyzed: {#less}, {merge#1,merge#2,merge,merge#3}, {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  msplit#3: runtime: O(1) [1], size: O(n^1) [2 + z + z' + z'']
  #cklt: runtime: O(1) [0], size: O(1) [2]

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

(43) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 1 }-> s3 :|: s3 >= 0, s3 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> s4 :|: s4 >= 0, s4 <= 2, s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0
   merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   merge#2(z, z', z'') -{ 2 }-> merge#3(s5, z', z'', @y, @ys) :|: s5 >= 0, s5 <= 2, s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0
   merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0
   merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0
   mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0
   mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   mergesort#1(z) -{ 1 }-> 0 :|: z = 0
   mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0
   mergesort#3(z) -{ 0 }-> 0 :|: z >= 0
   msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0
   msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0
   msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0
   msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0

Function symbols to be analyzed: {#less}, {merge#1,merge#2,merge,merge#3}, {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  msplit#3: runtime: O(1) [1], size: O(n^1) [2 + z + z' + z'']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: ?, size: O(1) [2]

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

(45) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 1 }-> s3 :|: s3 >= 0, s3 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> s4 :|: s4 >= 0, s4 <= 2, s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0
   merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   merge#2(z, z', z'') -{ 2 }-> merge#3(s5, z', z'', @y, @ys) :|: s5 >= 0, s5 <= 2, s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0
   merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0
   merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0
   mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0
   mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   mergesort#1(z) -{ 1 }-> 0 :|: z = 0
   mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0
   mergesort#3(z) -{ 0 }-> 0 :|: z >= 0
   msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0
   msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0
   msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0
   msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0

Function symbols to be analyzed: {merge#1,merge#2,merge,merge#3}, {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  msplit#3: runtime: O(1) [1], size: O(n^1) [2 + z + z' + z'']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: O(1) [1], size: O(1) [2]

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

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

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

   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 1 }-> s3 :|: s3 >= 0, s3 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> s4 :|: s4 >= 0, s4 <= 2, s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0
   merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   merge#2(z, z', z'') -{ 2 }-> merge#3(s5, z', z'', @y, @ys) :|: s5 >= 0, s5 <= 2, s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0
   merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0
   merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0
   mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0
   mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   mergesort#1(z) -{ 1 }-> 0 :|: z = 0
   mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0
   mergesort#3(z) -{ 0 }-> 0 :|: z >= 0
   msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0
   msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0
   msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0
   msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0

Function symbols to be analyzed: {merge#1,merge#2,merge,merge#3}, {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  msplit#3: runtime: O(1) [1], size: O(n^1) [2 + z + z' + z'']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: O(1) [1], size: O(1) [2]

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

(49) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

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

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

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

   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 1 }-> s3 :|: s3 >= 0, s3 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> s4 :|: s4 >= 0, s4 <= 2, s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0
   merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   merge#2(z, z', z'') -{ 2 }-> merge#3(s5, z', z'', @y, @ys) :|: s5 >= 0, s5 <= 2, s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0
   merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0
   merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0
   mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0
   mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   mergesort#1(z) -{ 1 }-> 0 :|: z = 0
   mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0
   mergesort#3(z) -{ 0 }-> 0 :|: z >= 0
   msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0
   msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0
   msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0
   msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0

Function symbols to be analyzed: {merge#1,merge#2,merge,merge#3}, {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  msplit#3: runtime: O(1) [1], size: O(n^1) [2 + z + z' + z'']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: O(1) [1], size: O(1) [2]
  merge#1: runtime: ?, size: O(n^1) [z + z']
  merge#2: runtime: ?, size: O(n^1) [1 + z + z' + z'']
  merge: runtime: ?, size: O(n^1) [z + z']
  merge#3: runtime: ?, size: O(n^1) [2 + z' + z'' + z1 + z2]

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

(51) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

Computed RUNTIME bound using CoFloCo for: merge#3
after applying outer abstraction to obtain an ITS,
resulting in: O(n^1) with polynomial bound: 21 + 5*z' + 5*z'' + 5*z1 + 5*z2

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

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

   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 1 }-> s3 :|: s3 >= 0, s3 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> s4 :|: s4 >= 0, s4 <= 2, s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   merge(z, z') -{ 1 }-> merge#1(z, z') :|: z >= 0, z' >= 0
   merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   merge#1(z, z') -{ 1 }-> merge#2(z', @x, @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   merge#2(z, z', z'') -{ 2 }-> merge#3(s5, z', z'', @y, @ys) :|: s5 >= 0, s5 <= 2, s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0
   merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0
   merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z' + merge(z'', 1 + z1 + z2) :|: z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + z1 + merge(1 + z' + z'', z2) :|: z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0
   mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0
   mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   mergesort#1(z) -{ 1 }-> 0 :|: z = 0
   mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0
   mergesort#3(z) -{ 0 }-> 0 :|: z >= 0
   msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0
   msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0
   msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0
   msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0

Function symbols to be analyzed: {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  msplit#3: runtime: O(1) [1], size: O(n^1) [2 + z + z' + z'']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: O(1) [1], size: O(1) [2]
  merge#1: runtime: O(n^1) [14 + 5*z + 5*z'], size: O(n^1) [z + z']
  merge#2: runtime: O(n^1) [18 + 5*z + 5*z' + 5*z''], size: O(n^1) [1 + z + z' + z'']
  merge: runtime: O(n^1) [15 + 5*z + 5*z'], size: O(n^1) [z + z']
  merge#3: runtime: O(n^1) [21 + 5*z' + 5*z'' + 5*z1 + 5*z2], size: O(n^1) [2 + z' + z'' + z1 + z2]

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

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

   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 1 }-> s3 :|: s3 >= 0, s3 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> s4 :|: s4 >= 0, s4 <= 2, s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   merge(z, z') -{ 15 + 5*z + 5*z' }-> s6 :|: s6 >= 0, s6 <= z + z', z >= 0, z' >= 0
   merge#1(z, z') -{ 19 + 5*@x + 5*@xs + 5*z' }-> s7 :|: s7 >= 0, s7 <= z' + @x + @xs + 1, @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   merge#2(z, z', z'') -{ 23 + 5*@y + 5*@ys + 5*z' + 5*z'' }-> s10 :|: s10 >= 0, s10 <= z' + z'' + @y + @ys + 2, s5 >= 0, s5 <= 2, s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0
   merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0
   merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0
   merge#3(z, z', z'', z1, z2) -{ 21 + 5*z'' + 5*z1 + 5*z2 }-> 1 + z' + s9 :|: s9 >= 0, s9 <= z'' + (1 + z1 + z2), z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   merge#3(z, z', z'', z1, z2) -{ 21 + 5*z' + 5*z'' + 5*z2 }-> 1 + z1 + s8 :|: s8 >= 0, s8 <= 1 + z' + z'' + z2, z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0
   mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0
   mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   mergesort#1(z) -{ 1 }-> 0 :|: z = 0
   mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0
   mergesort#3(z) -{ 0 }-> 0 :|: z >= 0
   msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0
   msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0
   msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0
   msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0

Function symbols to be analyzed: {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  msplit#3: runtime: O(1) [1], size: O(n^1) [2 + z + z' + z'']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: O(1) [1], size: O(1) [2]
  merge#1: runtime: O(n^1) [14 + 5*z + 5*z'], size: O(n^1) [z + z']
  merge#2: runtime: O(n^1) [18 + 5*z + 5*z' + 5*z''], size: O(n^1) [1 + z + z' + z'']
  merge: runtime: O(n^1) [15 + 5*z + 5*z'], size: O(n^1) [z + z']
  merge#3: runtime: O(n^1) [21 + 5*z' + 5*z'' + 5*z1 + 5*z2], size: O(n^1) [2 + z' + z'' + z1 + z2]

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

(55) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

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

   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 1 }-> s3 :|: s3 >= 0, s3 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> s4 :|: s4 >= 0, s4 <= 2, s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   merge(z, z') -{ 15 + 5*z + 5*z' }-> s6 :|: s6 >= 0, s6 <= z + z', z >= 0, z' >= 0
   merge#1(z, z') -{ 19 + 5*@x + 5*@xs + 5*z' }-> s7 :|: s7 >= 0, s7 <= z' + @x + @xs + 1, @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   merge#2(z, z', z'') -{ 23 + 5*@y + 5*@ys + 5*z' + 5*z'' }-> s10 :|: s10 >= 0, s10 <= z' + z'' + @y + @ys + 2, s5 >= 0, s5 <= 2, s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0
   merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0
   merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0
   merge#3(z, z', z'', z1, z2) -{ 21 + 5*z'' + 5*z1 + 5*z2 }-> 1 + z' + s9 :|: s9 >= 0, s9 <= z'' + (1 + z1 + z2), z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   merge#3(z, z', z'', z1, z2) -{ 21 + 5*z' + 5*z'' + 5*z2 }-> 1 + z1 + s8 :|: s8 >= 0, s8 <= 1 + z' + z'' + z2, z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0
   mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0
   mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   mergesort#1(z) -{ 1 }-> 0 :|: z = 0
   mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0
   mergesort#3(z) -{ 0 }-> 0 :|: z >= 0
   msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0
   msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0
   msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0
   msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0

Function symbols to be analyzed: {msplit#1,msplit#2}, {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  msplit#3: runtime: O(1) [1], size: O(n^1) [2 + z + z' + z'']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: O(1) [1], size: O(1) [2]
  merge#1: runtime: O(n^1) [14 + 5*z + 5*z'], size: O(n^1) [z + z']
  merge#2: runtime: O(n^1) [18 + 5*z + 5*z' + 5*z''], size: O(n^1) [1 + z + z' + z'']
  merge: runtime: O(n^1) [15 + 5*z + 5*z'], size: O(n^1) [z + z']
  merge#3: runtime: O(n^1) [21 + 5*z' + 5*z'' + 5*z1 + 5*z2], size: O(n^1) [2 + z' + z'' + z1 + z2]
  msplit#1: runtime: ?, size: O(n^1) [1 + z]
  msplit#2: runtime: ?, size: O(n^1) [2 + z + z']

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

(57) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

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

   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 1 }-> s3 :|: s3 >= 0, s3 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> s4 :|: s4 >= 0, s4 <= 2, s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   merge(z, z') -{ 15 + 5*z + 5*z' }-> s6 :|: s6 >= 0, s6 <= z + z', z >= 0, z' >= 0
   merge#1(z, z') -{ 19 + 5*@x + 5*@xs + 5*z' }-> s7 :|: s7 >= 0, s7 <= z' + @x + @xs + 1, @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   merge#2(z, z', z'') -{ 23 + 5*@y + 5*@ys + 5*z' + 5*z'' }-> s10 :|: s10 >= 0, s10 <= z' + z'' + @y + @ys + 2, s5 >= 0, s5 <= 2, s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0
   merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0
   merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0
   merge#3(z, z', z'', z1, z2) -{ 21 + 5*z'' + 5*z1 + 5*z2 }-> 1 + z' + s9 :|: s9 >= 0, s9 <= z'' + (1 + z1 + z2), z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   merge#3(z, z', z'', z1, z2) -{ 21 + 5*z' + 5*z'' + 5*z2 }-> 1 + z1 + s8 :|: s8 >= 0, s8 <= 1 + z' + z'' + z2, z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0
   mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0
   mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   mergesort#1(z) -{ 1 }-> 0 :|: z = 0
   mergesort#2(z, z') -{ 2 }-> mergesort#3(msplit#1(1 + z' + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0
   mergesort#3(z) -{ 0 }-> 0 :|: z >= 0
   msplit(z) -{ 1 }-> msplit#1(z) :|: z >= 0
   msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0
   msplit#2(z, z') -{ 2 }-> msplit#3(msplit#1(@xs'), z', @x2) :|: z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0
   msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0

Function symbols to be analyzed: {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  msplit#3: runtime: O(1) [1], size: O(n^1) [2 + z + z' + z'']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: O(1) [1], size: O(1) [2]
  merge#1: runtime: O(n^1) [14 + 5*z + 5*z'], size: O(n^1) [z + z']
  merge#2: runtime: O(n^1) [18 + 5*z + 5*z' + 5*z''], size: O(n^1) [1 + z + z' + z'']
  merge: runtime: O(n^1) [15 + 5*z + 5*z'], size: O(n^1) [z + z']
  merge#3: runtime: O(n^1) [21 + 5*z' + 5*z'' + 5*z1 + 5*z2], size: O(n^1) [2 + z' + z'' + z1 + z2]
  msplit#1: runtime: O(n^1) [2 + 4*z], size: O(n^1) [1 + z]
  msplit#2: runtime: O(n^1) [1 + 4*z], size: O(n^1) [2 + z + z']

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

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

   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 1 }-> s3 :|: s3 >= 0, s3 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> s4 :|: s4 >= 0, s4 <= 2, s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   merge(z, z') -{ 15 + 5*z + 5*z' }-> s6 :|: s6 >= 0, s6 <= z + z', z >= 0, z' >= 0
   merge#1(z, z') -{ 19 + 5*@x + 5*@xs + 5*z' }-> s7 :|: s7 >= 0, s7 <= z' + @x + @xs + 1, @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   merge#2(z, z', z'') -{ 23 + 5*@y + 5*@ys + 5*z' + 5*z'' }-> s10 :|: s10 >= 0, s10 <= z' + z'' + @y + @ys + 2, s5 >= 0, s5 <= 2, s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0
   merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0
   merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0
   merge#3(z, z', z'', z1, z2) -{ 21 + 5*z'' + 5*z1 + 5*z2 }-> 1 + z' + s9 :|: s9 >= 0, s9 <= z'' + (1 + z1 + z2), z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   merge#3(z, z', z'', z1, z2) -{ 21 + 5*z' + 5*z'' + 5*z2 }-> 1 + z1 + s8 :|: s8 >= 0, s8 <= 1 + z' + z'' + z2, z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0
   mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0
   mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   mergesort#1(z) -{ 1 }-> 0 :|: z = 0
   mergesort#2(z, z') -{ 12 + 4*@x2 + 4*@xs' + 4*z' }-> mergesort#3(s11) :|: s11 >= 0, s11 <= 1 + z' + (1 + @x2 + @xs') + 1, z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0
   mergesort#3(z) -{ 0 }-> 0 :|: z >= 0
   msplit(z) -{ 3 + 4*z }-> s12 :|: s12 >= 0, s12 <= z + 1, z >= 0
   msplit#1(z) -{ 2 + 4*@xs }-> s13 :|: s13 >= 0, s13 <= @xs + @x1 + 2, @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0
   msplit#2(z, z') -{ 5 + 4*@xs' }-> s15 :|: s14 >= 0, s14 <= @xs' + 1, s15 >= 0, s15 <= s14 + z' + @x2 + 2, z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0
   msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0

Function symbols to be analyzed: {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  msplit#3: runtime: O(1) [1], size: O(n^1) [2 + z + z' + z'']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: O(1) [1], size: O(1) [2]
  merge#1: runtime: O(n^1) [14 + 5*z + 5*z'], size: O(n^1) [z + z']
  merge#2: runtime: O(n^1) [18 + 5*z + 5*z' + 5*z''], size: O(n^1) [1 + z + z' + z'']
  merge: runtime: O(n^1) [15 + 5*z + 5*z'], size: O(n^1) [z + z']
  merge#3: runtime: O(n^1) [21 + 5*z' + 5*z'' + 5*z1 + 5*z2], size: O(n^1) [2 + z' + z'' + z1 + z2]
  msplit#1: runtime: O(n^1) [2 + 4*z], size: O(n^1) [1 + z]
  msplit#2: runtime: O(n^1) [1 + 4*z], size: O(n^1) [2 + z + z']

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

(61) IntTrsBoundProof (UPPER BOUND(ID))

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

Computed SIZE bound using KoAT for: mergesort#1
after applying outer abstraction to obtain an ITS,
resulting in: O(n^2) with polynomial bound: 35 + 27*z + 4*z^2

Computed SIZE bound using KoAT for: mergesort#2
after applying outer abstraction to obtain an ITS,
resulting in: O(n^2) with polynomial bound: 35 + 13*z + 2*z*z' + z^2 + 14*z' + z'^2

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

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

   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 1 }-> s3 :|: s3 >= 0, s3 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> s4 :|: s4 >= 0, s4 <= 2, s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   merge(z, z') -{ 15 + 5*z + 5*z' }-> s6 :|: s6 >= 0, s6 <= z + z', z >= 0, z' >= 0
   merge#1(z, z') -{ 19 + 5*@x + 5*@xs + 5*z' }-> s7 :|: s7 >= 0, s7 <= z' + @x + @xs + 1, @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   merge#2(z, z', z'') -{ 23 + 5*@y + 5*@ys + 5*z' + 5*z'' }-> s10 :|: s10 >= 0, s10 <= z' + z'' + @y + @ys + 2, s5 >= 0, s5 <= 2, s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0
   merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0
   merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0
   merge#3(z, z', z'', z1, z2) -{ 21 + 5*z'' + 5*z1 + 5*z2 }-> 1 + z' + s9 :|: s9 >= 0, s9 <= z'' + (1 + z1 + z2), z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   merge#3(z, z', z'', z1, z2) -{ 21 + 5*z' + 5*z'' + 5*z2 }-> 1 + z1 + s8 :|: s8 >= 0, s8 <= 1 + z' + z'' + z2, z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0
   mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0
   mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   mergesort#1(z) -{ 1 }-> 0 :|: z = 0
   mergesort#2(z, z') -{ 12 + 4*@x2 + 4*@xs' + 4*z' }-> mergesort#3(s11) :|: s11 >= 0, s11 <= 1 + z' + (1 + @x2 + @xs') + 1, z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0
   mergesort#3(z) -{ 0 }-> 0 :|: z >= 0
   msplit(z) -{ 3 + 4*z }-> s12 :|: s12 >= 0, s12 <= z + 1, z >= 0
   msplit#1(z) -{ 2 + 4*@xs }-> s13 :|: s13 >= 0, s13 <= @xs + @x1 + 2, @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0
   msplit#2(z, z') -{ 5 + 4*@xs' }-> s15 :|: s14 >= 0, s14 <= @xs' + 1, s15 >= 0, s15 <= s14 + z' + @x2 + 2, z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0
   msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0

Function symbols to be analyzed: {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  msplit#3: runtime: O(1) [1], size: O(n^1) [2 + z + z' + z'']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: O(1) [1], size: O(1) [2]
  merge#1: runtime: O(n^1) [14 + 5*z + 5*z'], size: O(n^1) [z + z']
  merge#2: runtime: O(n^1) [18 + 5*z + 5*z' + 5*z''], size: O(n^1) [1 + z + z' + z'']
  merge: runtime: O(n^1) [15 + 5*z + 5*z'], size: O(n^1) [z + z']
  merge#3: runtime: O(n^1) [21 + 5*z' + 5*z'' + 5*z1 + 5*z2], size: O(n^1) [2 + z' + z'' + z1 + z2]
  msplit#1: runtime: O(n^1) [2 + 4*z], size: O(n^1) [1 + z]
  msplit#2: runtime: O(n^1) [1 + 4*z], size: O(n^1) [2 + z + z']
  mergesort#3: runtime: ?, size: O(n^2) [12 + 9*z + z^2]
  mergesort#1: runtime: ?, size: O(n^2) [35 + 27*z + 4*z^2]
  mergesort#2: runtime: ?, size: O(n^2) [35 + 13*z + 2*z*z' + z^2 + 14*z' + z'^2]

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

(63) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: z >= 0
   #compare(z, z') -{ 0 }-> s :|: s >= 0, s <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 3, z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: z - 1 >= 0, z' - 1 >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #less(z, z') -{ 1 }-> s3 :|: s3 >= 0, s3 <= 2, s'' >= 0, s'' <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> s4 :|: s4 >= 0, s4 <= 2, s1 >= 0, s1 <= 3, z' - 1 >= 0, z - 1 >= 0
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z - 1 >= 0, z' = 0, 3 = 3
   #less(z, z') -{ 1 }-> 2 :|: z' - 1 >= 0, z - 1 >= 0, 3 = 3
   #less(z, z') -{ 1 }-> 1 :|: z = 0, z' = 0, 1 = 1
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z - 1 >= 0, z' = 0, 2 = 2
   #less(z, z') -{ 1 }-> 1 :|: z' - 1 >= 0, z - 1 >= 0, 2 = 2
   #less(z, z') -{ 1 }-> 0 :|: z = 0, z' = 0, v0 >= 0, 1 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 3 = v0
   #less(z, z') -{ 1 }-> 0 :|: z - 1 >= 0, z' = 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z' - 1 >= 0, z - 1 >= 0, v0 >= 0, 2 = v0
   #less(z, z') -{ 1 }-> 0 :|: z >= 0, z' >= 0, v0 >= 0, 0 = v0
   merge(z, z') -{ 15 + 5*z + 5*z' }-> s6 :|: s6 >= 0, s6 <= z + z', z >= 0, z' >= 0
   merge#1(z, z') -{ 19 + 5*@x + 5*@xs + 5*z' }-> s7 :|: s7 >= 0, s7 <= z' + @x + @xs + 1, @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   merge#1(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   merge#2(z, z', z'') -{ 23 + 5*@y + 5*@ys + 5*z' + 5*z'' }-> s10 :|: s10 >= 0, s10 <= z' + z'' + @y + @ys + 2, s5 >= 0, s5 <= 2, s2 >= 0, s2 <= 3, z = 1 + @y + @ys, z' >= 0, z'' >= 0, @y >= 0, @ys >= 0
   merge#2(z, z', z'') -{ 1 }-> 1 + z' + z'' :|: z' >= 0, z'' >= 0, z = 0
   merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z >= 0, z2 >= 0, z' >= 0, z'' >= 0, z1 >= 0
   merge#3(z, z', z'', z1, z2) -{ 21 + 5*z'' + 5*z1 + 5*z2 }-> 1 + z' + s9 :|: s9 >= 0, s9 <= z'' + (1 + z1 + z2), z = 2, z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   merge#3(z, z', z'', z1, z2) -{ 21 + 5*z' + 5*z'' + 5*z2 }-> 1 + z1 + s8 :|: s8 >= 0, s8 <= 1 + z' + z'' + z2, z' >= 0, z = 1, z'' >= 0, z1 >= 0, z2 >= 0
   mergesort(z) -{ 1 }-> mergesort#1(z) :|: z >= 0
   mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   mergesort#1(z) -{ 1 }-> 0 :|: z = 0
   mergesort#2(z, z') -{ 12 + 4*@x2 + 4*@xs' + 4*z' }-> mergesort#3(s11) :|: s11 >= 0, s11 <= 1 + z' + (1 + @x2 + @xs') + 1, z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   mergesort#2(z, z') -{ 1 }-> 1 + z' + 0 :|: z' >= 0, z = 0
   mergesort#3(z) -{ 3 }-> merge(mergesort#1(@l1), mergesort#1(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0
   mergesort#3(z) -{ 0 }-> 0 :|: z >= 0
   msplit(z) -{ 3 + 4*z }-> s12 :|: s12 >= 0, s12 <= z + 1, z >= 0
   msplit#1(z) -{ 2 + 4*@xs }-> s13 :|: s13 >= 0, s13 <= @xs + @x1 + 2, @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0
   msplit#2(z, z') -{ 5 + 4*@xs' }-> s15 :|: s14 >= 0, s14 <= @xs' + 1, s15 >= 0, s15 <= s14 + z' + @x2 + 2, z = 1 + @x2 + @xs', @xs' >= 0, z' >= 0, @x2 >= 0
   msplit#2(z, z') -{ 1 }-> 1 + (1 + z' + 0) + 0 :|: z' >= 0, z = 0
   msplit#3(z, z', z'') -{ 0 }-> 0 :|: z >= 0, z' >= 0, z'' >= 0
   msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + z' + @l1) + (1 + z'' + @l2) :|: @l1 >= 0, z = 1 + @l1 + @l2, z' >= 0, @l2 >= 0, z'' >= 0

Function symbols to be analyzed: {mergesort#3,mergesort#1,mergesort#2}, {msplit}, {mergesort}
Previous analysis results are:
  #compare: runtime: O(1) [0], size: O(1) [3]
  msplit#3: runtime: O(1) [1], size: O(n^1) [2 + z + z' + z'']
  #cklt: runtime: O(1) [0], size: O(1) [2]
  #less: runtime: O(1) [1], size: O(1) [2]
  merge#1: runtime: O(n^1) [14 + 5*z + 5*z'], size: O(n^1) [z + z']
  merge#2: runtime: O(n^1) [18 + 5*z + 5*z' + 5*z''], size: O(n^1) [1 + z + z' + z'']
  merge: runtime: O(n^1) [15 + 5*z + 5*z'], size: O(n^1) [z + z']
  merge#3: runtime: O(n^1) [21 + 5*z' + 5*z'' + 5*z1 + 5*z2], size: O(n^1) [2 + z' + z'' + z1 + z2]
  msplit#1: runtime: O(n^1) [2 + 4*z], size: O(n^1) [1 + z]
  msplit#2: runtime: O(n^1) [1 + 4*z], size: O(n^1) [2 + z + z']
  mergesort#3: runtime: INF, size: O(n^2) [12 + 9*z + z^2]
  mergesort#1: runtime: ?, size: O(n^2) [35 + 27*z + 4*z^2]
  mergesort#2: runtime: ?, size: O(n^2) [35 + 13*z + 2*z*z' + z^2 + 14*z' + z'^2]

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

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

   #cklt(v0) -> null_#cklt [0]
   #compare(v0, v1) -> null_#compare [0]
   merge#3(v0, v1, v2, v3, v4) -> null_merge#3 [0]
   mergesort#3(v0) -> null_mergesort#3 [0]
   msplit#3(v0, v1, v2) -> null_msplit#3 [0]
   merge#1(v0, v1) -> null_merge#1 [0]
   merge#2(v0, v1, v2) -> null_merge#2 [0]
   mergesort#1(v0) -> null_mergesort#1 [0]
   mergesort#2(v0, v1) -> null_mergesort#2 [0]
   msplit#1(v0) -> null_msplit#1 [0]
   msplit#2(v0, v1) -> null_msplit#2 [0]

And the following fresh constants:    null_#cklt, null_#compare, null_merge#3, null_mergesort#3, null_msplit#3, null_merge#1, null_merge#2, null_mergesort#1, null_mergesort#2, null_msplit#1, null_msplit#2

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

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

   #less(@x, @y) -> #cklt(#compare(@x, @y)) [1]
   merge(@l1, @l2) -> merge#1(@l1, @l2) [1]
   merge#1(::(@x, @xs), @l2) -> merge#2(@l2, @x, @xs) [1]
   merge#1(nil, @l2) -> @l2 [1]
   merge#2(::(@y, @ys), @x, @xs) -> merge#3(#less(@x, @y), @x, @xs, @y, @ys) [1]
   merge#2(nil, @x, @xs) -> ::(@x, @xs) [1]
   merge#3(#false, @x, @xs, @y, @ys) -> ::(@y, merge(::(@x, @xs), @ys)) [1]
   merge#3(#true, @x, @xs, @y, @ys) -> ::(@x, merge(@xs, ::(@y, @ys))) [1]
   mergesort(@l) -> mergesort#1(@l) [1]
   mergesort#1(::(@x1, @xs)) -> mergesort#2(@xs, @x1) [1]
   mergesort#1(nil) -> nil [1]
   mergesort#2(::(@x2, @xs'), @x1) -> mergesort#3(msplit(::(@x1, ::(@x2, @xs')))) [1]
   mergesort#2(nil, @x1) -> ::(@x1, nil) [1]
   mergesort#3(tuple#2(@l1, @l2)) -> merge(mergesort(@l1), mergesort(@l2)) [1]
   msplit(@l) -> msplit#1(@l) [1]
   msplit#1(::(@x1, @xs)) -> msplit#2(@xs, @x1) [1]
   msplit#1(nil) -> tuple#2(nil, nil) [1]
   msplit#2(::(@x2, @xs'), @x1) -> msplit#3(msplit(@xs'), @x1, @x2) [1]
   msplit#2(nil, @x1) -> tuple#2(::(@x1, nil), nil) [1]
   msplit#3(tuple#2(@l1, @l2), @x1, @x2) -> tuple#2(::(@x1, @l1), ::(@x2, @l2)) [1]
   #cklt(#EQ) -> #false [0]
   #cklt(#GT) -> #false [0]
   #cklt(#LT) -> #true [0]
   #compare(#0, #0) -> #EQ [0]
   #compare(#0, #neg(@y)) -> #GT [0]
   #compare(#0, #pos(@y)) -> #LT [0]
   #compare(#0, #s(@y)) -> #LT [0]
   #compare(#neg(@x), #0) -> #LT [0]
   #compare(#neg(@x), #neg(@y)) -> #compare(@y, @x) [0]
   #compare(#neg(@x), #pos(@y)) -> #LT [0]
   #compare(#pos(@x), #0) -> #GT [0]
   #compare(#pos(@x), #neg(@y)) -> #GT [0]
   #compare(#pos(@x), #pos(@y)) -> #compare(@x, @y) [0]
   #compare(#s(@x), #0) -> #GT [0]
   #compare(#s(@x), #s(@y)) -> #compare(@x, @y) [0]
   #cklt(v0) -> null_#cklt [0]
   #compare(v0, v1) -> null_#compare [0]
   merge#3(v0, v1, v2, v3, v4) -> null_merge#3 [0]
   mergesort#3(v0) -> null_mergesort#3 [0]
   msplit#3(v0, v1, v2) -> null_msplit#3 [0]
   merge#1(v0, v1) -> null_merge#1 [0]
   merge#2(v0, v1, v2) -> null_merge#2 [0]
   mergesort#1(v0) -> null_mergesort#1 [0]
   mergesort#2(v0, v1) -> null_mergesort#2 [0]
   msplit#1(v0) -> null_msplit#1 [0]
   msplit#2(v0, v1) -> null_msplit#2 [0]

The TRS has the following type information:
#less :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #false:#true:null_#cklt
#cklt :: #EQ:#GT:#LT:null_#compare -> #false:#true:null_#cklt
#compare :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> #EQ:#GT:#LT:null_#compare
merge :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2
merge#1 :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2
:: :: #0:#neg:#pos:#s -> :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2
merge#2 :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> #0:#neg:#pos:#s -> :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2
nil :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2
merge#3 :: #false:#true:null_#cklt -> #0:#neg:#pos:#s -> :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> #0:#neg:#pos:#s -> :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2
#false :: #false:#true:null_#cklt
#true :: #false:#true:null_#cklt
mergesort :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2
mergesort#1 :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2
mergesort#2 :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> #0:#neg:#pos:#s -> :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2
mergesort#3 :: tuple#2:null_msplit#3:null_msplit#1:null_msplit#2 -> :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2
msplit :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> tuple#2:null_msplit#3:null_msplit#1:null_msplit#2
tuple#2 :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> tuple#2:null_msplit#3:null_msplit#1:null_msplit#2
msplit#1 :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> tuple#2:null_msplit#3:null_msplit#1:null_msplit#2
msplit#2 :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2 -> #0:#neg:#pos:#s -> tuple#2:null_msplit#3:null_msplit#1:null_msplit#2
msplit#3 :: tuple#2:null_msplit#3:null_msplit#1:null_msplit#2 -> #0:#neg:#pos:#s -> #0:#neg:#pos:#s -> tuple#2:null_msplit#3:null_msplit#1:null_msplit#2
#EQ :: #EQ:#GT:#LT:null_#compare
#GT :: #EQ:#GT:#LT:null_#compare
#LT :: #EQ:#GT:#LT:null_#compare
#0 :: #0:#neg:#pos:#s
#neg :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#pos :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
#s :: #0:#neg:#pos:#s -> #0:#neg:#pos:#s
null_#cklt :: #false:#true:null_#cklt
null_#compare :: #EQ:#GT:#LT:null_#compare
null_merge#3 :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2
null_mergesort#3 :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2
null_msplit#3 :: tuple#2:null_msplit#3:null_msplit#1:null_msplit#2
null_merge#1 :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2
null_merge#2 :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2
null_mergesort#1 :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2
null_mergesort#2 :: :::nil:null_merge#3:null_mergesort#3:null_merge#1:null_merge#2:null_mergesort#1:null_mergesort#2
null_msplit#1 :: tuple#2:null_msplit#3:null_msplit#1:null_msplit#2
null_msplit#2 :: tuple#2:null_msplit#3:null_msplit#1:null_msplit#2

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

(67) 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
   #EQ => 1
   #GT => 2
   #LT => 3
   #0 => 0
   null_#cklt => 0
   null_#compare => 0
   null_merge#3 => 0
   null_mergesort#3 => 0
   null_msplit#3 => 0
   null_merge#1 => 0
   null_merge#2 => 0
   null_mergesort#1 => 0
   null_mergesort#2 => 0
   null_msplit#1 => 0
   null_msplit#2 => 0

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

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

   #cklt(z) -{ 0 }-> 2 :|: z = 3
   #cklt(z) -{ 0 }-> 1 :|: z = 1
   #cklt(z) -{ 0 }-> 1 :|: z = 2
   #cklt(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   #compare(z, z') -{ 0 }-> 3 :|: z = 0, z' = 1 + @y, @y >= 0
   #compare(z, z') -{ 0 }-> 3 :|: @x >= 0, z = 1 + @x, z' = 0
   #compare(z, z') -{ 0 }-> 3 :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0
   #compare(z, z') -{ 0 }-> 2 :|: z = 0, z' = 1 + @y, @y >= 0
   #compare(z, z') -{ 0 }-> 2 :|: @x >= 0, z = 1 + @x, z' = 0
   #compare(z, z') -{ 0 }-> 2 :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0
   #compare(z, z') -{ 0 }-> 1 :|: z = 0, z' = 0
   #compare(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   #compare(z, z') -{ 0 }-> #compare(@x, @y) :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0
   #compare(z, z') -{ 0 }-> #compare(@y, @x) :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0
   #less(z, z') -{ 1 }-> #cklt(#compare(@x, @y)) :|: z = @x, @x >= 0, z' = @y, @y >= 0
   merge(z, z') -{ 1 }-> merge#1(@l1, @l2) :|: @l1 >= 0, z' = @l2, @l2 >= 0, z = @l1
   merge#1(z, z') -{ 1 }-> @l2 :|: z' = @l2, @l2 >= 0, z = 0
   merge#1(z, z') -{ 1 }-> merge#2(@l2, @x, @xs) :|: z' = @l2, @x >= 0, z = 1 + @x + @xs, @l2 >= 0, @xs >= 0
   merge#1(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   merge#2(z, z', z'') -{ 1 }-> merge#3(#less(@x, @y), @x, @xs, @y, @ys) :|: z = 1 + @y + @ys, @x >= 0, @xs >= 0, @y >= 0, z' = @x, z'' = @xs, @ys >= 0
   merge#2(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   merge#2(z, z', z'') -{ 1 }-> 1 + @x + @xs :|: @x >= 0, @xs >= 0, z = 0, z' = @x, z'' = @xs
   merge#3(z, z', z'', z1, z2) -{ 0 }-> 0 :|: z1 = v3, v0 >= 0, v4 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, z2 = v4, v2 >= 0, v3 >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + @x + merge(@xs, 1 + @y + @ys) :|: z = 2, @x >= 0, z1 = @y, @xs >= 0, z2 = @ys, @y >= 0, z' = @x, z'' = @xs, @ys >= 0
   merge#3(z, z', z'', z1, z2) -{ 1 }-> 1 + @y + merge(1 + @x + @xs, @ys) :|: @x >= 0, z = 1, z1 = @y, @xs >= 0, z2 = @ys, @y >= 0, z' = @x, z'' = @xs, @ys >= 0
   mergesort(z) -{ 1 }-> mergesort#1(@l) :|: z = @l, @l >= 0
   mergesort#1(z) -{ 1 }-> mergesort#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   mergesort#1(z) -{ 1 }-> 0 :|: z = 0
   mergesort#1(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   mergesort#2(z, z') -{ 1 }-> mergesort#3(msplit(1 + @x1 + (1 + @x2 + @xs'))) :|: z = 1 + @x2 + @xs', z' = @x1, @xs' >= 0, @x1 >= 0, @x2 >= 0
   mergesort#2(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   mergesort#2(z, z') -{ 1 }-> 1 + @x1 + 0 :|: z' = @x1, @x1 >= 0, z = 0
   mergesort#3(z) -{ 1 }-> merge(mergesort(@l1), mergesort(@l2)) :|: @l1 >= 0, z = 1 + @l1 + @l2, @l2 >= 0
   mergesort#3(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   msplit(z) -{ 1 }-> msplit#1(@l) :|: z = @l, @l >= 0
   msplit#1(z) -{ 1 }-> msplit#2(@xs, @x1) :|: @x1 >= 0, z = 1 + @x1 + @xs, @xs >= 0
   msplit#1(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   msplit#1(z) -{ 1 }-> 1 + 0 + 0 :|: z = 0
   msplit#2(z, z') -{ 1 }-> msplit#3(msplit(@xs'), @x1, @x2) :|: z = 1 + @x2 + @xs', z' = @x1, @xs' >= 0, @x1 >= 0, @x2 >= 0
   msplit#2(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   msplit#2(z, z') -{ 1 }-> 1 + (1 + @x1 + 0) + 0 :|: z' = @x1, @x1 >= 0, z = 0
   msplit#3(z, z', z'') -{ 0 }-> 0 :|: v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0
   msplit#3(z, z', z'') -{ 1 }-> 1 + (1 + @x1 + @l1) + (1 + @x2 + @l2) :|: z' = @x1, @l1 >= 0, z = 1 + @l1 + @l2, z'' = @x2, @x1 >= 0, @l2 >= 0, @x2 >= 0

Only complete derivations are relevant for the runtime complexity.

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

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

(70)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #CKLT(#EQ) -> c
   #CKLT(#GT) -> c1
   #CKLT(#LT) -> c2
   #COMPARE(#0, #0) -> c3
   #COMPARE(#0, #neg(z0)) -> c4
   #COMPARE(#0, #pos(z0)) -> c5
   #COMPARE(#0, #s(z0)) -> c6
   #COMPARE(#neg(z0), #0) -> c7
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#neg(z0), #pos(z1)) -> c9
   #COMPARE(#pos(z0), #0) -> c10
   #COMPARE(#pos(z0), #neg(z1)) -> c11
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #0) -> c13
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   #LESS(z0, z1) -> c15(#CKLT(#compare(z0, z1)), #COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#1(nil, z0) -> c18
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   MERGE#2(nil, z0, z1) -> c20
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MERGESORT#1(nil) -> c25
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT#2(nil, z0) -> c27
   MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#1(nil) -> c32
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT#3(msplit(z1), z2, z0), MSPLIT(z1))
   MSPLIT#2(nil, z0) -> c34
   MSPLIT#3(tuple#2(z0, z1), z2, z3) -> c35
S tuples:
   #LESS(z0, z1) -> c15(#CKLT(#compare(z0, z1)), #COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#1(nil, z0) -> c18
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   MERGE#2(nil, z0, z1) -> c20
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MERGESORT#1(nil) -> c25
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT#2(nil, z0) -> c27
   MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#1(nil) -> c32
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT#3(msplit(z1), z2, z0), MSPLIT(z1))
   MSPLIT#2(nil, z0) -> c34
   MSPLIT#3(tuple#2(z0, z1), z2, z3) -> c35
K tuples:none
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #CKLT_1, #COMPARE_2, #LESS_2, MERGE_2, MERGE#1_2, MERGE#2_3, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MERGESORT#2_2, MERGESORT#3_1, MSPLIT_1, MSPLIT#1_1, MSPLIT#2_2, MSPLIT#3_3

Compound Symbols:   c, c1, c2, c3, c4, c5, c6, c7, c8_1, c9, c10, c11, c12_1, c13, c14_1, c15_2, c16_1, c17_1, c18, c19_2, c20, c21_1, c22_1, c23_1, c24_1, c25, c26_2, c27, c28_2, c29_2, c30_1, c31_1, c32, c33_2, c34, c35


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

(71) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 19 trailing nodes:
   #COMPARE(#s(z0), #0) -> c13
   MERGESORT#1(nil) -> c25
   #COMPARE(#pos(z0), #0) -> c10
   #CKLT(#GT) -> c1
   #CKLT(#LT) -> c2
   #COMPARE(#0, #s(z0)) -> c6
   MERGE#2(nil, z0, z1) -> c20
   #CKLT(#EQ) -> c
   MSPLIT#2(nil, z0) -> c34
   #COMPARE(#0, #pos(z0)) -> c5
   MERGE#1(nil, z0) -> c18
   MSPLIT#1(nil) -> c32
   MSPLIT#3(tuple#2(z0, z1), z2, z3) -> c35
   #COMPARE(#0, #0) -> c3
   MERGESORT#2(nil, z0) -> c27
   #COMPARE(#0, #neg(z0)) -> c4
   #COMPARE(#neg(z0), #pos(z1)) -> c9
   #COMPARE(#neg(z0), #0) -> c7
   #COMPARE(#pos(z0), #neg(z1)) -> c11

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

(72)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   #LESS(z0, z1) -> c15(#CKLT(#compare(z0, z1)), #COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT#3(msplit(z1), z2, z0), MSPLIT(z1))
S tuples:
   #LESS(z0, z1) -> c15(#CKLT(#compare(z0, z1)), #COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT#3(msplit(z1), z2, z0), MSPLIT(z1))
K tuples:none
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, #LESS_2, MERGE_2, MERGE#1_2, MERGE#2_3, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MERGESORT#2_2, MERGESORT#3_1, MSPLIT_1, MSPLIT#1_1, MSPLIT#2_2

Compound Symbols:   c8_1, c12_1, c14_1, c15_2, c16_1, c17_1, c19_2, c21_1, c22_1, c23_1, c24_1, c26_2, c28_2, c29_2, c30_1, c31_1, c33_2


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

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

(74)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
K tuples:none
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#2_3, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MERGESORT#2_2, MERGESORT#3_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2

Compound Symbols:   c8_1, c12_1, c14_1, c16_1, c17_1, c19_2, c21_1, c22_1, c23_1, c24_1, c26_2, c28_2, c29_2, c30_1, c31_1, c15_1, c33_1


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

(75) CdtRuleRemovalProof (UPPER BOUND(ADD(n^2)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
We considered the (Usable) Rules:
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   #compare(#0, #neg(z0)) -> #GT
   msplit#1(nil) -> tuple#2(nil, nil)
   #compare(#pos(z0), #0) -> #GT
   #cklt(#GT) -> #false
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   #compare(#pos(z0), #neg(z1)) -> #GT
   merge(z0, z1) -> merge#1(z0, z1)
   mergesort#2(nil, z0) -> ::(z0, nil)
   merge#1(nil, z0) -> z0
   #compare(#0, #pos(z0)) -> #LT
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #compare(#0, #0) -> #EQ
   #compare(#s(z0), #0) -> #GT
   msplit(z0) -> msplit#1(z0)
   #cklt(#EQ) -> #false
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   mergesort(z0) -> mergesort#1(z0)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   #cklt(#LT) -> #true
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
And the Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(#0) = [2]
   POL(#COMPARE(x_1, x_2)) = 0
   POL(#EQ) = 0
   POL(#GT) = 0
   POL(#LESS(x_1, x_2)) = 0
   POL(#LT) = [1]
   POL(#cklt(x_1)) = [2]x_1
   POL(#compare(x_1, x_2)) = x_1*x_2
   POL(#false) = 0
   POL(#less(x_1, x_2)) = [2]x_1*x_2
   POL(#neg(x_1)) = [2] + x_1
   POL(#pos(x_1)) = [2] + x_1
   POL(#s(x_1)) = [1] + x_1
   POL(#true) = [2]
   POL(::(x_1, x_2)) = x_1 + x_2
   POL(MERGE(x_1, x_2)) = [2]x_1*x_2
   POL(MERGE#1(x_1, x_2)) = [2]x_1*x_2
   POL(MERGE#2(x_1, x_2, x_3)) = [2]x_1*x_3 + [2]x_1*x_2
   POL(MERGE#3(x_1, x_2, x_3, x_4, x_5)) = x_1 + [2]x_3*x_5 + [2]x_2*x_5 + [2]x_3*x_4
   POL(MERGESORT(x_1)) = x_1^2
   POL(MERGESORT#1(x_1)) = x_1^2
   POL(MERGESORT#2(x_1, x_2)) = x_2^2 + [2]x_1*x_2 + x_1^2
   POL(MERGESORT#3(x_1)) = x_1^2
   POL(MSPLIT(x_1)) = 0
   POL(MSPLIT#1(x_1)) = 0
   POL(MSPLIT#2(x_1, x_2)) = 0
   POL(c12(x_1)) = x_1
   POL(c14(x_1)) = x_1
   POL(c15(x_1)) = x_1
   POL(c16(x_1)) = x_1
   POL(c17(x_1)) = x_1
   POL(c19(x_1, x_2)) = x_1 + x_2
   POL(c21(x_1)) = x_1
   POL(c22(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c24(x_1)) = x_1
   POL(c26(x_1, x_2)) = x_1 + x_2
   POL(c28(x_1, x_2)) = x_1 + x_2
   POL(c29(x_1, x_2)) = x_1 + x_2
   POL(c30(x_1)) = x_1
   POL(c31(x_1)) = x_1
   POL(c33(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(merge(x_1, x_2)) = x_1 + x_2
   POL(merge#1(x_1, x_2)) = x_1 + x_2
   POL(merge#2(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(merge#3(x_1, x_2, x_3, x_4, x_5)) = x_2 + x_3 + x_4 + x_5
   POL(mergesort(x_1)) = x_1
   POL(mergesort#1(x_1)) = x_1
   POL(mergesort#2(x_1, x_2)) = x_1 + x_2
   POL(mergesort#3(x_1)) = x_1
   POL(msplit(x_1)) = x_1
   POL(msplit#1(x_1)) = x_1
   POL(msplit#2(x_1, x_2)) = x_1 + x_2
   POL(msplit#3(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(nil) = 0
   POL(tuple#2(x_1, x_2)) = x_1 + x_2

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

(76)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
K tuples:
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#2_3, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MERGESORT#2_2, MERGESORT#3_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2

Compound Symbols:   c8_1, c12_1, c14_1, c16_1, c17_1, c19_2, c21_1, c22_1, c23_1, c24_1, c26_2, c28_2, c29_2, c30_1, c31_1, c15_1, c33_1


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

(77) CdtRuleRemovalProof (UPPER BOUND(ADD(n^2)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
We considered the (Usable) Rules:
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   #compare(#0, #neg(z0)) -> #GT
   msplit#1(nil) -> tuple#2(nil, nil)
   #compare(#pos(z0), #0) -> #GT
   #cklt(#GT) -> #false
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   #compare(#pos(z0), #neg(z1)) -> #GT
   merge(z0, z1) -> merge#1(z0, z1)
   mergesort#2(nil, z0) -> ::(z0, nil)
   merge#1(nil, z0) -> z0
   #compare(#0, #pos(z0)) -> #LT
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #compare(#0, #0) -> #EQ
   #compare(#s(z0), #0) -> #GT
   msplit(z0) -> msplit#1(z0)
   #cklt(#EQ) -> #false
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   mergesort(z0) -> mergesort#1(z0)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   #cklt(#LT) -> #true
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
And the Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(#0) = [1]
   POL(#COMPARE(x_1, x_2)) = 0
   POL(#EQ) = [1]
   POL(#GT) = [1]
   POL(#LESS(x_1, x_2)) = 0
   POL(#LT) = 0
   POL(#cklt(x_1)) = x_1
   POL(#compare(x_1, x_2)) = x_1*x_2
   POL(#false) = [1]
   POL(#less(x_1, x_2)) = x_1*x_2
   POL(#neg(x_1)) = [1] + x_1
   POL(#pos(x_1)) = [1] + x_1
   POL(#s(x_1)) = [1] + x_1
   POL(#true) = 0
   POL(::(x_1, x_2)) = x_1 + x_2
   POL(MERGE(x_1, x_2)) = x_1*x_2
   POL(MERGE#1(x_1, x_2)) = x_1*x_2
   POL(MERGE#2(x_1, x_2, x_3)) = x_1*x_3 + x_1*x_2
   POL(MERGE#3(x_1, x_2, x_3, x_4, x_5)) = x_1 + x_3*x_5 + x_2*x_5 + x_3*x_4
   POL(MERGESORT(x_1)) = x_1^2
   POL(MERGESORT#1(x_1)) = x_1^2
   POL(MERGESORT#2(x_1, x_2)) = x_2^2 + [2]x_1*x_2 + x_1^2
   POL(MERGESORT#3(x_1)) = x_1^2
   POL(MSPLIT(x_1)) = 0
   POL(MSPLIT#1(x_1)) = 0
   POL(MSPLIT#2(x_1, x_2)) = 0
   POL(c12(x_1)) = x_1
   POL(c14(x_1)) = x_1
   POL(c15(x_1)) = x_1
   POL(c16(x_1)) = x_1
   POL(c17(x_1)) = x_1
   POL(c19(x_1, x_2)) = x_1 + x_2
   POL(c21(x_1)) = x_1
   POL(c22(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c24(x_1)) = x_1
   POL(c26(x_1, x_2)) = x_1 + x_2
   POL(c28(x_1, x_2)) = x_1 + x_2
   POL(c29(x_1, x_2)) = x_1 + x_2
   POL(c30(x_1)) = x_1
   POL(c31(x_1)) = x_1
   POL(c33(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(merge(x_1, x_2)) = x_1 + x_2
   POL(merge#1(x_1, x_2)) = x_1 + x_2
   POL(merge#2(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(merge#3(x_1, x_2, x_3, x_4, x_5)) = x_2 + x_3 + x_4 + x_5
   POL(mergesort(x_1)) = x_1
   POL(mergesort#1(x_1)) = x_1
   POL(mergesort#2(x_1, x_2)) = x_1 + x_2
   POL(mergesort#3(x_1)) = x_1
   POL(msplit(x_1)) = x_1
   POL(msplit#1(x_1)) = x_1
   POL(msplit#2(x_1, x_2)) = x_1 + x_2
   POL(msplit#3(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(nil) = 0
   POL(tuple#2(x_1, x_2)) = x_1 + x_2

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

(78)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
K tuples:
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#2_3, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MERGESORT#2_2, MERGESORT#3_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2

Compound Symbols:   c8_1, c12_1, c14_1, c16_1, c17_1, c19_2, c21_1, c22_1, c23_1, c24_1, c26_2, c28_2, c29_2, c30_1, c31_1, c15_1, c33_1


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

(79) CdtRuleRemovalProof (UPPER BOUND(ADD(n^2)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
We considered the (Usable) Rules:
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(nil, z0) -> ::(z0, nil)
   merge#1(nil, z0) -> z0
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   msplit(z0) -> msplit#1(z0)
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   merge#2(nil, z0, z1) -> ::(z0, z1)
   mergesort(z0) -> mergesort#1(z0)
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
And the Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(#0) = [2]
   POL(#COMPARE(x_1, x_2)) = 0
   POL(#EQ) = [2]
   POL(#GT) = [1]
   POL(#LESS(x_1, x_2)) = 0
   POL(#LT) = [1]
   POL(#cklt(x_1)) = [1]
   POL(#compare(x_1, x_2)) = 0
   POL(#false) = 0
   POL(#less(x_1, x_2)) = 0
   POL(#neg(x_1)) = 0
   POL(#pos(x_1)) = 0
   POL(#s(x_1)) = 0
   POL(#true) = 0
   POL(::(x_1, x_2)) = [1] + x_2
   POL(MERGE(x_1, x_2)) = x_1*x_2
   POL(MERGE#1(x_1, x_2)) = x_1*x_2
   POL(MERGE#2(x_1, x_2, x_3)) = x_1 + x_1*x_3
   POL(MERGE#3(x_1, x_2, x_3, x_4, x_5)) = x_3 + x_5 + x_3*x_5
   POL(MERGESORT(x_1)) = [1] + x_1^2
   POL(MERGESORT#1(x_1)) = [1] + x_1^2
   POL(MERGESORT#2(x_1, x_2)) = [2] + [2]x_1 + x_1^2
   POL(MERGESORT#3(x_1)) = [1] + x_1^2
   POL(MSPLIT(x_1)) = 0
   POL(MSPLIT#1(x_1)) = 0
   POL(MSPLIT#2(x_1, x_2)) = 0
   POL(c12(x_1)) = x_1
   POL(c14(x_1)) = x_1
   POL(c15(x_1)) = x_1
   POL(c16(x_1)) = x_1
   POL(c17(x_1)) = x_1
   POL(c19(x_1, x_2)) = x_1 + x_2
   POL(c21(x_1)) = x_1
   POL(c22(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c24(x_1)) = x_1
   POL(c26(x_1, x_2)) = x_1 + x_2
   POL(c28(x_1, x_2)) = x_1 + x_2
   POL(c29(x_1, x_2)) = x_1 + x_2
   POL(c30(x_1)) = x_1
   POL(c31(x_1)) = x_1
   POL(c33(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(merge(x_1, x_2)) = x_1 + x_2
   POL(merge#1(x_1, x_2)) = x_1 + x_2
   POL(merge#2(x_1, x_2, x_3)) = [1] + x_1 + x_3
   POL(merge#3(x_1, x_2, x_3, x_4, x_5)) = [2] + x_3 + x_5
   POL(mergesort(x_1)) = x_1
   POL(mergesort#1(x_1)) = x_1
   POL(mergesort#2(x_1, x_2)) = [1] + x_1
   POL(mergesort#3(x_1)) = x_1
   POL(msplit(x_1)) = x_1
   POL(msplit#1(x_1)) = x_1
   POL(msplit#2(x_1, x_2)) = [1] + x_1
   POL(msplit#3(x_1, x_2, x_3)) = [2] + x_1
   POL(nil) = 0
   POL(tuple#2(x_1, x_2)) = x_1 + x_2

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

(80)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
K tuples:
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#2_3, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MERGESORT#2_2, MERGESORT#3_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2

Compound Symbols:   c8_1, c12_1, c14_1, c16_1, c17_1, c19_2, c21_1, c22_1, c23_1, c24_1, c26_2, c28_2, c29_2, c30_1, c31_1, c15_1, c33_1


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

(81) CdtKnowledgeProof (BOTH BOUNDS(ID, ID))
The following tuples could be moved from S to K by knowledge propagation:
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))

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

(82)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
K tuples:
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#2_3, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MERGESORT#2_2, MERGESORT#3_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2

Compound Symbols:   c8_1, c12_1, c14_1, c16_1, c17_1, c19_2, c21_1, c22_1, c23_1, c24_1, c26_2, c28_2, c29_2, c30_1, c31_1, c15_1, c33_1


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

(83) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0)) by 
   MERGE#2(::(z1, x1), z0, x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), z0, x3, z1, x1), #LESS(z0, z1))

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

(84)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(z1, x1), z0, x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), z0, x3, z1, x1), #LESS(z0, z1))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
K tuples:
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MERGESORT#2_2, MERGESORT#3_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3

Compound Symbols:   c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c26_2, c28_2, c29_2, c30_1, c31_1, c15_1, c33_1, c19_2


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

(85) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit(::(z2, ::(z0, z1)))), MSPLIT(::(z2, ::(z0, z1)))) by 
   MERGESORT#2(::(x0, x1), x2) -> c26(MERGESORT#3(msplit#1(::(x2, ::(x0, x1)))), MSPLIT(::(x2, ::(x0, x1))))

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

(86)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(z1, x1), z0, x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), z0, x3, z1, x1), #LESS(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MERGESORT#3(msplit#1(::(x2, ::(x0, x1)))), MSPLIT(::(x2, ::(x0, x1))))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MERGESORT#3(msplit#1(::(x2, ::(x0, x1)))), MSPLIT(::(x2, ::(x0, x1))))
K tuples:
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MERGESORT#3_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2

Compound Symbols:   c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c28_2, c29_2, c30_1, c31_1, c15_1, c33_1, c19_2, c26_2


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

(87) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MERGESORT#3(tuple#2(z0, z1)) -> c28(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z0)) by 
   MERGESORT#3(tuple#2(x0, z0)) -> c28(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0))

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

(88)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(z1, x1), z0, x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), z0, x3, z1, x1), #LESS(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MERGESORT#3(msplit#1(::(x2, ::(x0, x1)))), MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, z0)) -> c28(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MERGESORT#3(msplit#1(::(x2, ::(x0, x1)))), MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, z0)) -> c28(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0))
K tuples:
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MERGESORT#3_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2

Compound Symbols:   c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c29_2, c30_1, c31_1, c15_1, c33_1, c19_2, c26_2, c28_2


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

(89) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MERGESORT#3(tuple#2(z0, z1)) -> c29(MERGE(mergesort(z0), mergesort(z1)), MERGESORT(z1)) by 
   MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1))

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

(90)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(z1, x1), z0, x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), z0, x3, z1, x1), #LESS(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MERGESORT#3(msplit#1(::(x2, ::(x0, x1)))), MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, z0)) -> c28(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MERGESORT#3(msplit#1(::(x2, ::(x0, x1)))), MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, z0)) -> c28(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1))
K tuples:
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1

Compound Symbols:   c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c26_2, c28_2, c29_2


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

(91) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MERGE#2(::(z1, x1), z0, x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), z0, x3, z1, x1), #LESS(z0, z1)) by 
   MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0))
   MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0))
   MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))

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

(92)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MERGESORT#3(msplit#1(::(x2, ::(x0, x1)))), MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, z0)) -> c28(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1))
   MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0))
   MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0))
   MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MERGESORT#3(msplit#1(::(x2, ::(x0, x1)))), MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, z0)) -> c28(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1))
K tuples:
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGESORT#2_2, MERGESORT#3_1, MERGE#2_3

Compound Symbols:   c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c26_2, c28_2, c29_2, c19_2, c19_1


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

(93) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MERGESORT#2(::(x0, x1), x2) -> c26(MERGESORT#3(msplit#1(::(x2, ::(x0, x1)))), MSPLIT(::(x2, ::(x0, x1)))) by 
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))

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

(94)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(x0, z0)) -> c28(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1))
   MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0))
   MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0))
   MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(x0, z0)) -> c28(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
K tuples:
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGESORT#3_1, MERGE#2_3, MERGESORT#2_2

Compound Symbols:   c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c28_2, c29_2, c19_2, c19_1, c26_2, c26_1


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

(95) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
We considered the (Usable) Rules:none
And the Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(x0, z0)) -> c28(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1))
   MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0))
   MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0))
   MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(#0) = 0
   POL(#COMPARE(x_1, x_2)) = 0
   POL(#EQ) = [1]
   POL(#GT) = [1]
   POL(#LESS(x_1, x_2)) = 0
   POL(#LT) = [1]
   POL(#cklt(x_1)) = [1]
   POL(#compare(x_1, x_2)) = x_1 + x_2
   POL(#false) = [1]
   POL(#less(x_1, x_2)) = [1] + x_1 + x_2
   POL(#neg(x_1)) = 0
   POL(#pos(x_1)) = 0
   POL(#s(x_1)) = 0
   POL(#true) = [1]
   POL(::(x_1, x_2)) = 0
   POL(MERGE(x_1, x_2)) = 0
   POL(MERGE#1(x_1, x_2)) = 0
   POL(MERGE#2(x_1, x_2, x_3)) = 0
   POL(MERGE#3(x_1, x_2, x_3, x_4, x_5)) = 0
   POL(MERGESORT(x_1)) = [1]
   POL(MERGESORT#1(x_1)) = [1]
   POL(MERGESORT#2(x_1, x_2)) = [1]
   POL(MERGESORT#3(x_1)) = [1]
   POL(MSPLIT(x_1)) = 0
   POL(MSPLIT#1(x_1)) = 0
   POL(MSPLIT#2(x_1, x_2)) = 0
   POL(c12(x_1)) = x_1
   POL(c14(x_1)) = x_1
   POL(c15(x_1)) = x_1
   POL(c16(x_1)) = x_1
   POL(c17(x_1)) = x_1
   POL(c19(x_1)) = x_1
   POL(c19(x_1, x_2)) = x_1 + x_2
   POL(c21(x_1)) = x_1
   POL(c22(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c24(x_1)) = x_1
   POL(c26(x_1)) = x_1
   POL(c26(x_1, x_2)) = x_1 + x_2
   POL(c28(x_1, x_2)) = x_1 + x_2
   POL(c29(x_1, x_2)) = x_1 + x_2
   POL(c30(x_1)) = x_1
   POL(c31(x_1)) = x_1
   POL(c33(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(merge(x_1, x_2)) = [1] + x_1 + x_2
   POL(merge#1(x_1, x_2)) = [1] + x_1 + x_2
   POL(merge#2(x_1, x_2, x_3)) = [1] + x_1 + x_2 + x_3
   POL(merge#3(x_1, x_2, x_3, x_4, x_5)) = [1] + x_2 + x_3 + x_4 + x_5
   POL(mergesort(x_1)) = [1] + x_1
   POL(mergesort#1(x_1)) = [1] + x_1
   POL(mergesort#2(x_1, x_2)) = [1] + x_1 + x_2
   POL(mergesort#3(x_1)) = [1]
   POL(msplit(x_1)) = [1] + x_1
   POL(msplit#1(x_1)) = [1] + x_1
   POL(msplit#2(x_1, x_2)) = [1] + x_1 + x_2
   POL(msplit#3(x_1, x_2, x_3)) = [1] + x_2 + x_3
   POL(nil) = 0
   POL(tuple#2(x_1, x_2)) = 0

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

(96)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(x0, z0)) -> c28(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1))
   MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0))
   MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0))
   MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(x0, z0)) -> c28(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
K tuples:
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGESORT#3_1, MERGE#2_3, MERGESORT#2_2

Compound Symbols:   c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c28_2, c29_2, c19_2, c19_1, c26_2, c26_1


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

(97) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MERGESORT#3(tuple#2(x0, z0)) -> c28(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(x0)) by 
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))

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

(98)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1))
   MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0))
   MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0))
   MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
K tuples:
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGESORT#3_1, MERGE#2_3, MERGESORT#2_2

Compound Symbols:   c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c28_2, c29_2, c19_2, c19_1, c26_2, c26_1


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

(99) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
We considered the (Usable) Rules:
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
And the Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1))
   MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0))
   MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0))
   MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(#0) = 0
   POL(#COMPARE(x_1, x_2)) = 0
   POL(#EQ) = 0
   POL(#GT) = 0
   POL(#LESS(x_1, x_2)) = 0
   POL(#LT) = 0
   POL(#cklt(x_1)) = 0
   POL(#compare(x_1, x_2)) = 0
   POL(#false) = 0
   POL(#less(x_1, x_2)) = [3] + [3]x_1 + [3]x_2
   POL(#neg(x_1)) = 0
   POL(#pos(x_1)) = 0
   POL(#s(x_1)) = 0
   POL(#true) = 0
   POL(::(x_1, x_2)) = 0
   POL(MERGE(x_1, x_2)) = 0
   POL(MERGE#1(x_1, x_2)) = 0
   POL(MERGE#2(x_1, x_2, x_3)) = 0
   POL(MERGE#3(x_1, x_2, x_3, x_4, x_5)) = 0
   POL(MERGESORT(x_1)) = 0
   POL(MERGESORT#1(x_1)) = 0
   POL(MERGESORT#2(x_1, x_2)) = 0
   POL(MERGESORT#3(x_1)) = x_1
   POL(MSPLIT(x_1)) = 0
   POL(MSPLIT#1(x_1)) = 0
   POL(MSPLIT#2(x_1, x_2)) = 0
   POL(c12(x_1)) = x_1
   POL(c14(x_1)) = x_1
   POL(c15(x_1)) = x_1
   POL(c16(x_1)) = x_1
   POL(c17(x_1)) = x_1
   POL(c19(x_1)) = x_1
   POL(c19(x_1, x_2)) = x_1 + x_2
   POL(c21(x_1)) = x_1
   POL(c22(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c24(x_1)) = x_1
   POL(c26(x_1)) = x_1
   POL(c26(x_1, x_2)) = x_1 + x_2
   POL(c28(x_1, x_2)) = x_1 + x_2
   POL(c29(x_1, x_2)) = x_1 + x_2
   POL(c30(x_1)) = x_1
   POL(c31(x_1)) = x_1
   POL(c33(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(merge(x_1, x_2)) = [3]
   POL(merge#1(x_1, x_2)) = [3] + [3]x_1 + [3]x_2
   POL(merge#2(x_1, x_2, x_3)) = [3] + [3]x_1 + [3]x_2 + [3]x_3
   POL(merge#3(x_1, x_2, x_3, x_4, x_5)) = [3] + [3]x_2 + [3]x_3 + [3]x_4 + [3]x_5
   POL(mergesort(x_1)) = [3]x_1
   POL(mergesort#1(x_1)) = [3]x_1
   POL(mergesort#2(x_1, x_2)) = [3] + [3]x_1 + [3]x_2
   POL(mergesort#3(x_1)) = [3]
   POL(msplit(x_1)) = 0
   POL(msplit#1(x_1)) = [3] + [3]x_1
   POL(msplit#2(x_1, x_2)) = 0
   POL(msplit#3(x_1, x_2, x_3)) = 0
   POL(nil) = [1]
   POL(tuple#2(x_1, x_2)) = x_2

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

(100)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1))
   MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0))
   MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0))
   MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
K tuples:
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGESORT#3_1, MERGE#2_3, MERGESORT#2_2

Compound Symbols:   c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c28_2, c29_2, c19_2, c19_1, c26_2, c26_1


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

(101) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
We considered the (Usable) Rules:
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit(z0) -> msplit#1(z0)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
And the Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1))
   MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0))
   MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0))
   MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(#0) = 0
   POL(#COMPARE(x_1, x_2)) = 0
   POL(#EQ) = 0
   POL(#GT) = 0
   POL(#LESS(x_1, x_2)) = 0
   POL(#LT) = 0
   POL(#cklt(x_1)) = 0
   POL(#compare(x_1, x_2)) = 0
   POL(#false) = 0
   POL(#less(x_1, x_2)) = [3] + [3]x_1 + [3]x_2
   POL(#neg(x_1)) = 0
   POL(#pos(x_1)) = 0
   POL(#s(x_1)) = 0
   POL(#true) = 0
   POL(::(x_1, x_2)) = [1] + x_2
   POL(MERGE(x_1, x_2)) = 0
   POL(MERGE#1(x_1, x_2)) = 0
   POL(MERGE#2(x_1, x_2, x_3)) = 0
   POL(MERGE#3(x_1, x_2, x_3, x_4, x_5)) = 0
   POL(MERGESORT(x_1)) = [2]x_1
   POL(MERGESORT#1(x_1)) = [2]x_1
   POL(MERGESORT#2(x_1, x_2)) = [2] + [2]x_1
   POL(MERGESORT#3(x_1)) = [2]x_1
   POL(MSPLIT(x_1)) = 0
   POL(MSPLIT#1(x_1)) = 0
   POL(MSPLIT#2(x_1, x_2)) = 0
   POL(c12(x_1)) = x_1
   POL(c14(x_1)) = x_1
   POL(c15(x_1)) = x_1
   POL(c16(x_1)) = x_1
   POL(c17(x_1)) = x_1
   POL(c19(x_1)) = x_1
   POL(c19(x_1, x_2)) = x_1 + x_2
   POL(c21(x_1)) = x_1
   POL(c22(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c24(x_1)) = x_1
   POL(c26(x_1)) = x_1
   POL(c26(x_1, x_2)) = x_1 + x_2
   POL(c28(x_1, x_2)) = x_1 + x_2
   POL(c29(x_1, x_2)) = x_1 + x_2
   POL(c30(x_1)) = x_1
   POL(c31(x_1)) = x_1
   POL(c33(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(merge(x_1, x_2)) = [3]
   POL(merge#1(x_1, x_2)) = [3] + [3]x_1 + [3]x_2
   POL(merge#2(x_1, x_2, x_3)) = [3] + [3]x_1 + [3]x_2 + [3]x_3
   POL(merge#3(x_1, x_2, x_3, x_4, x_5)) = [3] + [3]x_2 + [3]x_3 + [3]x_4 + [3]x_5
   POL(mergesort(x_1)) = [3]x_1
   POL(mergesort#1(x_1)) = [3]x_1
   POL(mergesort#2(x_1, x_2)) = [3] + [3]x_1 + [3]x_2
   POL(mergesort#3(x_1)) = [3]
   POL(msplit(x_1)) = x_1
   POL(msplit#1(x_1)) = x_1
   POL(msplit#2(x_1, x_2)) = [1] + x_1
   POL(msplit#3(x_1, x_2, x_3)) = [2] + x_1
   POL(nil) = 0
   POL(tuple#2(x_1, x_2)) = x_1 + x_2

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

(102)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1))
   MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0))
   MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0))
   MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
K tuples:
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGESORT#3_1, MERGE#2_3, MERGESORT#2_2

Compound Symbols:   c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c28_2, c29_2, c19_2, c19_1, c26_2, c26_1


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

(103) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(z0)) by 
   MERGESORT#3(tuple#2(x0, z0)) -> c28(MERGE(mergesort#1(x0), mergesort#1(z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))

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

(104)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1))
   MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0))
   MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0))
   MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
K tuples:
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGESORT#3_1, MERGE#2_3, MERGESORT#2_2

Compound Symbols:   c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c29_2, c19_2, c19_1, c26_2, c26_1, c28_2


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

(105) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
We considered the (Usable) Rules:
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
And the Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1))
   MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0))
   MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0))
   MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(#0) = 0
   POL(#COMPARE(x_1, x_2)) = 0
   POL(#EQ) = [1]
   POL(#GT) = [1]
   POL(#LESS(x_1, x_2)) = 0
   POL(#LT) = [1]
   POL(#cklt(x_1)) = [1]
   POL(#compare(x_1, x_2)) = 0
   POL(#false) = [1]
   POL(#less(x_1, x_2)) = [1] + x_1 + x_2
   POL(#neg(x_1)) = 0
   POL(#pos(x_1)) = 0
   POL(#s(x_1)) = 0
   POL(#true) = [1]
   POL(::(x_1, x_2)) = 0
   POL(MERGE(x_1, x_2)) = 0
   POL(MERGE#1(x_1, x_2)) = 0
   POL(MERGE#2(x_1, x_2, x_3)) = 0
   POL(MERGE#3(x_1, x_2, x_3, x_4, x_5)) = 0
   POL(MERGESORT(x_1)) = 0
   POL(MERGESORT#1(x_1)) = 0
   POL(MERGESORT#2(x_1, x_2)) = 0
   POL(MERGESORT#3(x_1)) = x_1
   POL(MSPLIT(x_1)) = 0
   POL(MSPLIT#1(x_1)) = 0
   POL(MSPLIT#2(x_1, x_2)) = 0
   POL(c12(x_1)) = x_1
   POL(c14(x_1)) = x_1
   POL(c15(x_1)) = x_1
   POL(c16(x_1)) = x_1
   POL(c17(x_1)) = x_1
   POL(c19(x_1)) = x_1
   POL(c19(x_1, x_2)) = x_1 + x_2
   POL(c21(x_1)) = x_1
   POL(c22(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c24(x_1)) = x_1
   POL(c26(x_1)) = x_1
   POL(c26(x_1, x_2)) = x_1 + x_2
   POL(c28(x_1, x_2)) = x_1 + x_2
   POL(c29(x_1, x_2)) = x_1 + x_2
   POL(c30(x_1)) = x_1
   POL(c31(x_1)) = x_1
   POL(c33(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(merge(x_1, x_2)) = [1] + x_1 + x_2
   POL(merge#1(x_1, x_2)) = [1] + x_1 + x_2
   POL(merge#2(x_1, x_2, x_3)) = [1] + x_1 + x_2 + x_3
   POL(merge#3(x_1, x_2, x_3, x_4, x_5)) = [1] + x_2 + x_3 + x_4 + x_5
   POL(mergesort(x_1)) = [1] + x_1
   POL(mergesort#1(x_1)) = [1] + x_1
   POL(mergesort#2(x_1, x_2)) = [1] + x_1 + x_2
   POL(mergesort#3(x_1)) = [1]
   POL(msplit(x_1)) = [1] + x_1
   POL(msplit#1(x_1)) = [1] + x_1
   POL(msplit#2(x_1, x_2)) = 0
   POL(msplit#3(x_1, x_2, x_3)) = 0
   POL(nil) = [1]
   POL(tuple#2(x_1, x_2)) = x_1

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

(106)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1))
   MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0))
   MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0))
   MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
K tuples:
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGESORT#3_1, MERGE#2_3, MERGESORT#2_2

Compound Symbols:   c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c29_2, c19_2, c19_1, c26_2, c26_1, c28_2


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

(107) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort(x0), mergesort#1(z0)), MERGESORT(z0)) by 
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))

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

(108)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1))
   MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0))
   MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0))
   MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
K tuples:
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGESORT#3_1, MERGE#2_3, MERGESORT#2_2

Compound Symbols:   c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c29_2, c19_2, c19_1, c26_2, c26_1, c28_2


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

(109) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
We considered the (Usable) Rules:
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
And the Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1))
   MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0))
   MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0))
   MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(#0) = 0
   POL(#COMPARE(x_1, x_2)) = 0
   POL(#EQ) = [1]
   POL(#GT) = [1]
   POL(#LESS(x_1, x_2)) = 0
   POL(#LT) = [1]
   POL(#cklt(x_1)) = [1]
   POL(#compare(x_1, x_2)) = 0
   POL(#false) = [1]
   POL(#less(x_1, x_2)) = [1] + x_1 + x_2
   POL(#neg(x_1)) = 0
   POL(#pos(x_1)) = 0
   POL(#s(x_1)) = 0
   POL(#true) = [1]
   POL(::(x_1, x_2)) = 0
   POL(MERGE(x_1, x_2)) = 0
   POL(MERGE#1(x_1, x_2)) = 0
   POL(MERGE#2(x_1, x_2, x_3)) = 0
   POL(MERGE#3(x_1, x_2, x_3, x_4, x_5)) = 0
   POL(MERGESORT(x_1)) = 0
   POL(MERGESORT#1(x_1)) = 0
   POL(MERGESORT#2(x_1, x_2)) = 0
   POL(MERGESORT#3(x_1)) = x_1
   POL(MSPLIT(x_1)) = 0
   POL(MSPLIT#1(x_1)) = 0
   POL(MSPLIT#2(x_1, x_2)) = 0
   POL(c12(x_1)) = x_1
   POL(c14(x_1)) = x_1
   POL(c15(x_1)) = x_1
   POL(c16(x_1)) = x_1
   POL(c17(x_1)) = x_1
   POL(c19(x_1)) = x_1
   POL(c19(x_1, x_2)) = x_1 + x_2
   POL(c21(x_1)) = x_1
   POL(c22(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c24(x_1)) = x_1
   POL(c26(x_1)) = x_1
   POL(c26(x_1, x_2)) = x_1 + x_2
   POL(c28(x_1, x_2)) = x_1 + x_2
   POL(c29(x_1, x_2)) = x_1 + x_2
   POL(c30(x_1)) = x_1
   POL(c31(x_1)) = x_1
   POL(c33(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(merge(x_1, x_2)) = [1] + x_1 + x_2
   POL(merge#1(x_1, x_2)) = [1] + x_1 + x_2
   POL(merge#2(x_1, x_2, x_3)) = [1] + x_1 + x_2 + x_3
   POL(merge#3(x_1, x_2, x_3, x_4, x_5)) = [1] + x_2 + x_3 + x_4 + x_5
   POL(mergesort(x_1)) = [1] + x_1
   POL(mergesort#1(x_1)) = [1] + x_1
   POL(mergesort#2(x_1, x_2)) = [1] + x_1 + x_2
   POL(mergesort#3(x_1)) = [1]
   POL(msplit(x_1)) = [1] + x_1
   POL(msplit#1(x_1)) = [1] + x_1
   POL(msplit#2(x_1, x_2)) = 0
   POL(msplit#3(x_1, x_2, x_3)) = 0
   POL(nil) = [1]
   POL(tuple#2(x_1, x_2)) = x_2

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

(110)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1))
   MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0))
   MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0))
   MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
K tuples:
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGESORT#3_1, MERGE#2_3, MERGESORT#2_2

Compound Symbols:   c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c29_2, c19_2, c19_1, c26_2, c26_1, c28_2


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

(111) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort(x1)), MERGESORT(x1)) by 
   MERGESORT#3(tuple#2(x0, z0)) -> c29(MERGE(mergesort#1(x0), mergesort#1(z0)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))

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

(112)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0))
   MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0))
   MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
K tuples:
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1

Compound Symbols:   c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2


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

(113) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
We considered the (Usable) Rules:
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
And the Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0))
   MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0))
   MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(#0) = 0
   POL(#COMPARE(x_1, x_2)) = 0
   POL(#EQ) = [1]
   POL(#GT) = [1]
   POL(#LESS(x_1, x_2)) = 0
   POL(#LT) = [1]
   POL(#cklt(x_1)) = [1]
   POL(#compare(x_1, x_2)) = 0
   POL(#false) = [1]
   POL(#less(x_1, x_2)) = [1] + x_1 + x_2
   POL(#neg(x_1)) = 0
   POL(#pos(x_1)) = 0
   POL(#s(x_1)) = 0
   POL(#true) = [1]
   POL(::(x_1, x_2)) = 0
   POL(MERGE(x_1, x_2)) = 0
   POL(MERGE#1(x_1, x_2)) = 0
   POL(MERGE#2(x_1, x_2, x_3)) = 0
   POL(MERGE#3(x_1, x_2, x_3, x_4, x_5)) = 0
   POL(MERGESORT(x_1)) = 0
   POL(MERGESORT#1(x_1)) = 0
   POL(MERGESORT#2(x_1, x_2)) = 0
   POL(MERGESORT#3(x_1)) = x_1
   POL(MSPLIT(x_1)) = 0
   POL(MSPLIT#1(x_1)) = 0
   POL(MSPLIT#2(x_1, x_2)) = 0
   POL(c12(x_1)) = x_1
   POL(c14(x_1)) = x_1
   POL(c15(x_1)) = x_1
   POL(c16(x_1)) = x_1
   POL(c17(x_1)) = x_1
   POL(c19(x_1)) = x_1
   POL(c19(x_1, x_2)) = x_1 + x_2
   POL(c21(x_1)) = x_1
   POL(c22(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c24(x_1)) = x_1
   POL(c26(x_1)) = x_1
   POL(c26(x_1, x_2)) = x_1 + x_2
   POL(c28(x_1, x_2)) = x_1 + x_2
   POL(c29(x_1, x_2)) = x_1 + x_2
   POL(c30(x_1)) = x_1
   POL(c31(x_1)) = x_1
   POL(c33(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(merge(x_1, x_2)) = [1] + x_1 + x_2
   POL(merge#1(x_1, x_2)) = [1] + x_1 + x_2
   POL(merge#2(x_1, x_2, x_3)) = [1] + x_1 + x_2 + x_3
   POL(merge#3(x_1, x_2, x_3, x_4, x_5)) = [1] + x_2 + x_3 + x_4 + x_5
   POL(mergesort(x_1)) = [1] + x_1
   POL(mergesort#1(x_1)) = [1] + x_1
   POL(mergesort#2(x_1, x_2)) = [1] + x_1 + x_2
   POL(mergesort#3(x_1)) = [1]
   POL(msplit(x_1)) = [1] + x_1
   POL(msplit#1(x_1)) = [1] + x_1
   POL(msplit#2(x_1, x_2)) = 0
   POL(msplit#3(x_1, x_2, x_3)) = 0
   POL(nil) = [1]
   POL(tuple#2(x_1, x_2)) = x_1

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

(114)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0))
   MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0))
   MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
K tuples:
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1

Compound Symbols:   c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2


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

(115) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
We considered the (Usable) Rules:
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit(z0) -> msplit#1(z0)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
And the Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0))
   MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0))
   MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(#0) = 0
   POL(#COMPARE(x_1, x_2)) = 0
   POL(#EQ) = 0
   POL(#GT) = 0
   POL(#LESS(x_1, x_2)) = 0
   POL(#LT) = 0
   POL(#cklt(x_1)) = 0
   POL(#compare(x_1, x_2)) = 0
   POL(#false) = 0
   POL(#less(x_1, x_2)) = [3] + [3]x_1 + [3]x_2
   POL(#neg(x_1)) = 0
   POL(#pos(x_1)) = 0
   POL(#s(x_1)) = 0
   POL(#true) = 0
   POL(::(x_1, x_2)) = [1] + x_2
   POL(MERGE(x_1, x_2)) = 0
   POL(MERGE#1(x_1, x_2)) = 0
   POL(MERGE#2(x_1, x_2, x_3)) = 0
   POL(MERGE#3(x_1, x_2, x_3, x_4, x_5)) = 0
   POL(MERGESORT(x_1)) = [2]x_1
   POL(MERGESORT#1(x_1)) = [2]x_1
   POL(MERGESORT#2(x_1, x_2)) = [2] + [2]x_1
   POL(MERGESORT#3(x_1)) = [2]x_1
   POL(MSPLIT(x_1)) = 0
   POL(MSPLIT#1(x_1)) = 0
   POL(MSPLIT#2(x_1, x_2)) = 0
   POL(c12(x_1)) = x_1
   POL(c14(x_1)) = x_1
   POL(c15(x_1)) = x_1
   POL(c16(x_1)) = x_1
   POL(c17(x_1)) = x_1
   POL(c19(x_1)) = x_1
   POL(c19(x_1, x_2)) = x_1 + x_2
   POL(c21(x_1)) = x_1
   POL(c22(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c24(x_1)) = x_1
   POL(c26(x_1)) = x_1
   POL(c26(x_1, x_2)) = x_1 + x_2
   POL(c28(x_1, x_2)) = x_1 + x_2
   POL(c29(x_1, x_2)) = x_1 + x_2
   POL(c30(x_1)) = x_1
   POL(c31(x_1)) = x_1
   POL(c33(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(merge(x_1, x_2)) = [3]
   POL(merge#1(x_1, x_2)) = [3] + [3]x_1 + [3]x_2
   POL(merge#2(x_1, x_2, x_3)) = [3] + [3]x_1 + [3]x_2 + [3]x_3
   POL(merge#3(x_1, x_2, x_3, x_4, x_5)) = [3] + [3]x_2 + [3]x_3 + [3]x_4 + [3]x_5
   POL(mergesort(x_1)) = [3]x_1
   POL(mergesort#1(x_1)) = [3]x_1
   POL(mergesort#2(x_1, x_2)) = [3]x_1 + [3]x_2
   POL(mergesort#3(x_1)) = [3]
   POL(msplit(x_1)) = x_1
   POL(msplit#1(x_1)) = x_1
   POL(msplit#2(x_1, x_2)) = [1] + x_1
   POL(msplit#3(x_1, x_2, x_3)) = [2] + x_1
   POL(nil) = 0
   POL(tuple#2(x_1, x_2)) = x_1 + x_2

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

(116)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0))
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0))
   MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0))
   MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
K tuples:
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1

Compound Symbols:   c8_1, c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2


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

(117) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace #COMPARE(#neg(z0), #neg(z1)) -> c8(#COMPARE(z1, z0)) by 
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))

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

(118)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0))
   MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0))
   MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
K tuples:
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1

Compound Symbols:   c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1


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

(119) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace MERGE#2(::(#0, x1), #0, x3) -> c19(MERGE#3(#cklt(#EQ), #0, x3, #0, x1), #LESS(#0, #0)) by MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0))
----------------------------------------

(120)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1))
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0))
   MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
K tuples:
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1

Compound Symbols:   c12_1, c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1


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

(121) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace #COMPARE(#pos(z0), #pos(z1)) -> c12(#COMPARE(z0, z1)) by 
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))

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

(122)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0))
   MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
K tuples:
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1

Compound Symbols:   c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1, c12_1


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

(123) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace MERGE#2(::(#neg(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#GT), #0, x3, #neg(z0), x1), #LESS(#0, #neg(z0))) by MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0)))
----------------------------------------

(124)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0))
   MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0)))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
K tuples:
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1

Compound Symbols:   c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1, c12_1


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

(125) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace MERGE#2(::(#pos(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #pos(z0), x1), #LESS(#0, #pos(z0))) by MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0)))
----------------------------------------

(126)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0))
   MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0)))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
K tuples:
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1

Compound Symbols:   c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1, c12_1


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

(127) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace MERGE#2(::(#s(z0), x1), #0, x3) -> c19(MERGE#3(#cklt(#LT), #0, x3, #s(z0), x1), #LESS(#0, #s(z0))) by MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0)))
----------------------------------------

(128)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0))
   MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0)))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
K tuples:
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1

Compound Symbols:   c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1, c12_1


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

(129) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace MERGE#2(::(#0, x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #0, x1), #LESS(#neg(z0), #0)) by MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0))
----------------------------------------

(130)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0))
   MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
K tuples:
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1

Compound Symbols:   c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1, c12_1


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

(131) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace MERGE#2(::(#pos(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#LT), #neg(z0), x3, #pos(z1), x1), #LESS(#neg(z0), #pos(z1))) by MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0)))
----------------------------------------

(132)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0))
   MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0))
   MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0)))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
K tuples:
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1

Compound Symbols:   c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1, c12_1


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

(133) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace MERGE#2(::(#0, x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #0, x1), #LESS(#pos(z0), #0)) by MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0))
----------------------------------------

(134)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0))
   MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0)))
   MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
K tuples:
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1

Compound Symbols:   c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1, c12_1


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

(135) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace MERGE#2(::(#neg(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#GT), #pos(z0), x3, #neg(z1), x1), #LESS(#pos(z0), #neg(z1))) by MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0)))
----------------------------------------

(136)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0))
   MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0)))
   MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0))
   MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0)))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
K tuples:
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1

Compound Symbols:   c14_1, c16_1, c17_1, c21_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1, c12_1


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

(137) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace MERGE#3(#false, z0, z1, z2, z3) -> c21(MERGE(::(z0, z1), z3)) by 
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))

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

(138)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0))
   MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0)))
   MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0))
   MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0)))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
K tuples:
   MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3)))
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGE#3_5, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1

Compound Symbols:   c14_1, c16_1, c17_1, c22_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1


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

(139) CdtInstantiationProof (BOTH BOUNDS(ID, ID))
Use instantiation to replace MERGE#3(#true, z0, z1, z2, z3) -> c22(MERGE(z1, ::(z2, z3))) by 
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))

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

(140)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0))
   MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0)))
   MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0))
   MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0)))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
K tuples:
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, MERGE#3_5

Compound Symbols:   c14_1, c16_1, c17_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1


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

(141) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MERGE#2(::(#0, x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#GT), #s(z0), x3, #0, x1), #LESS(#s(z0), #0)) by 
   MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0))

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

(142)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0))
   MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0)))
   MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0))
   MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0)))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
K tuples:
   MERGE#2(::(z0, z1), z2, z3) -> c19(MERGE#3(#less(z2, z0), z2, z3, z0, z1), #LESS(z2, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, MERGE#3_5

Compound Symbols:   c14_1, c16_1, c17_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1


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

(143) CdtLeafRemovalProof (ComplexityIfPolyImplication)
Removed 1 leading nodes:
   MERGE#3(#true, #s(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))

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

(144)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1))
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0))
   MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0)))
   MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0))
   MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0)))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
K tuples:
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #COMPARE_2, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, MERGE#3_5

Compound Symbols:   c14_1, c16_1, c17_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1


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

(145) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace #COMPARE(#s(z0), #s(z1)) -> c14(#COMPARE(z0, z1)) by 
   #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))

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

(146)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0))
   MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0)))
   MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0))
   MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0)))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0))
   #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
S tuples:
   MERGE(z0, z1) -> c16(MERGE#1(z0, z1))
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
K tuples:
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5

Compound Symbols:   c16_1, c17_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1


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

(147) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace MERGE(z0, z1) -> c16(MERGE#1(z0, z1)) by 
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))

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

(148)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0))
   MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0)))
   MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0))
   MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0)))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0))
   #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
S tuples:
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
K tuples:
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGE(nil, mergesort(x1)), MERGESORT(nil))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGE(nil, mergesort(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2

Compound Symbols:   c17_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1


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

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

(150)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0))
   MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0)))
   MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0))
   MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0)))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0))
   #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGESORT(nil))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
S tuples:
   MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1))
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
K tuples:
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGESORT(nil))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2

Compound Symbols:   c17_1, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c28_1, c29_1


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

(151) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace MERGE#1(::(z0, z1), z2) -> c17(MERGE#2(z2, z0, z1)) by 
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))

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

(152)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0))
   MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0)))
   MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0))
   MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0)))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0))
   #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGESORT(nil))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
S tuples:
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
K tuples:
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGESORT(nil))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2

Compound Symbols:   c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_2, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c28_1, c29_1, c17_1


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

(153) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace MERGESORT#2(::(x0, x1), z0) -> c26(MERGESORT#3(msplit#2(::(x0, x1), z0)), MSPLIT(::(z0, ::(x0, x1)))) by MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
----------------------------------------

(154)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0))
   MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0)))
   MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0))
   MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0)))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0))
   #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGESORT(nil))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
S tuples:
   MERGESORT(z0) -> c23(MERGESORT#1(z0))
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
K tuples:
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGESORT(nil))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2

Compound Symbols:   c23_1, c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c28_1, c29_1, c17_1, c26_2


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

(155) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace MERGESORT(z0) -> c23(MERGESORT#1(z0)) by 
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))

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

(156)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0))
   MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0)))
   MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0))
   MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0)))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0))
   #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGESORT(nil))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
S tuples:
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
K tuples:
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGESORT(nil))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1

Compound Symbols:   c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c28_1, c29_1, c17_1, c26_2, c23_1


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

(157) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   MERGESORT#3(tuple#2(nil, x1)) -> c28(MERGESORT(nil))

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

(158)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0))
   MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0)))
   MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0))
   MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0)))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0))
   #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
S tuples:
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
K tuples:
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil), MERGESORT(nil))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1

Compound Symbols:   c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c26_2, c23_1


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

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

(160)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0))
   MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0)))
   MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0))
   MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0)))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0))
   #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
S tuples:
   MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0))
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
K tuples:
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1

Compound Symbols:   c24_1, c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c26_2, c23_1


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

(161) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace MERGESORT#1(::(z0, z1)) -> c24(MERGESORT#2(z1, z0)) by 
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))

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

(162)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0))
   MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0)))
   MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0))
   MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0)))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0))
   #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
S tuples:
   MSPLIT(z0) -> c30(MSPLIT#1(z0))
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
K tuples:
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1

Compound Symbols:   c30_1, c31_1, c15_1, c33_1, c19_2, c19_1, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c26_2, c23_1, c24_1


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

(163) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace MSPLIT(z0) -> c30(MSPLIT#1(z0)) by 
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))

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

(164)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0))
   MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0)))
   MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0))
   MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0)))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0))
   #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
S tuples:
   MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
K tuples:
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   MSPLIT#1_1, #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1

Compound Symbols:   c31_1, c15_1, c33_1, c19_2, c19_1, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c26_2, c23_1, c24_1, c30_1


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

(165) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace MSPLIT#1(::(z0, z1)) -> c31(MSPLIT#2(z1, z0)) by 
   MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0))

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

(166)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0))
   MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0)))
   MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0))
   MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0)))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0))
   #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
   MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0))
S tuples:
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
   MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0))
K tuples:
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1

Compound Symbols:   c15_1, c33_1, c19_2, c19_1, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c26_2, c23_1, c24_1, c30_1, c31_1


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

(167) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0)) by MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c28(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(z0))
----------------------------------------

(168)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0))
   MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0)))
   MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0))
   MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0)))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0))
   #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
   MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0))
   MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c28(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(z0))
S tuples:
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
   MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0))
K tuples:
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1

Compound Symbols:   c15_1, c33_1, c19_2, c19_1, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c26_2, c23_1, c24_1, c30_1, c31_1


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

(169) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0)) by MERGESORT#3(tuple#2(z0, nil)) -> c28(MERGE(mergesort#1(z0), nil), MERGESORT(z0))
----------------------------------------

(170)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0))
   MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0)))
   MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0))
   MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0)))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0))
   #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
   MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0))
   MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c28(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, nil)) -> c28(MERGE(mergesort#1(z0), nil), MERGESORT(z0))
S tuples:
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
   MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0))
K tuples:
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1

Compound Symbols:   c15_1, c33_1, c19_2, c19_1, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c26_2, c23_1, c24_1, c30_1, c31_1


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

(171) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c28(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(::(z0, z1))) by MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1)))
----------------------------------------

(172)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0))
   MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0)))
   MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0))
   MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0)))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0))
   #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
   MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0))
   MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c28(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, nil)) -> c28(MERGE(mergesort#1(z0), nil), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1)))
S tuples:
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
   MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1)))
K tuples:
   #LESS(z0, z1) -> c15(#COMPARE(z0, z1))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   #LESS_2, MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1

Compound Symbols:   c15_1, c33_1, c19_2, c19_1, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c26_2, c23_1, c24_1, c30_1, c31_1


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

(173) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace #LESS(z0, z1) -> c15(#COMPARE(z0, z1)) by 
   #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1))))
   #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))

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

(174)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0), #LESS(#0, #0))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1), #LESS(#0, #neg(z0)))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1), #LESS(#0, #pos(z0)))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1), #LESS(#0, #s(z0)))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0), #LESS(#neg(z1), #0))
   MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1), #LESS(#neg(z2), #pos(z0)))
   MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0), #LESS(#pos(z1), #0))
   MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1), #LESS(#pos(z2), #neg(z0)))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0), #LESS(#s(x1), #0))
   #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
   MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0))
   MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c28(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, nil)) -> c28(MERGE(mergesort#1(z0), nil), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1)))
   #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1))))
   #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))
S tuples:
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
   MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1)))
K tuples:
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
   #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1))))
   #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2

Compound Symbols:   c33_1, c19_2, c19_1, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c26_2, c23_1, c24_1, c30_1, c31_1, c15_1


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

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

(176)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
   MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0))
   MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c28(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, nil)) -> c28(MERGE(mergesort#1(z0), nil), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1)))
   #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1))))
   #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0))
   MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1))
   MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0))
   MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1))
   MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0))
S tuples:
   MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
   MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1)))
K tuples:
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
   #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1))))
   #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   MSPLIT#2_2, MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2

Compound Symbols:   c33_1, c19_2, c19_1, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c26_2, c23_1, c24_1, c30_1, c31_1, c15_1


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

(177) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace MSPLIT#2(::(z0, z1), z2) -> c33(MSPLIT(z1)) by 
   MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1)))

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

(178)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
   MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0))
   MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c28(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, nil)) -> c28(MERGE(mergesort#1(z0), nil), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1)))
   #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1))))
   #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0))
   MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1))
   MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0))
   MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1))
   MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0))
   MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1)))
S tuples:
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1)))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
   MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1)))
   MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1)))
K tuples:
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
   #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1))))
   #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2

Compound Symbols:   c19_2, c19_1, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c26_2, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1


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

(179) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c29(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(::(z0, z1))) by MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2)))
----------------------------------------

(180)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
   MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0))
   MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c28(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, nil)) -> c28(MERGE(mergesort#1(z0), nil), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1)))
   #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1))))
   #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0))
   MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1))
   MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0))
   MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1))
   MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0))
   MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1)))
   MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2)))
S tuples:
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
   MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1)))
   MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1)))
   MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2)))
K tuples:
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
   #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1))))
   #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2

Compound Symbols:   c19_2, c19_1, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c26_2, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1


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

(181) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1)) by MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c29(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(z2))
----------------------------------------

(182)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
   MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0))
   MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c28(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, nil)) -> c28(MERGE(mergesort#1(z0), nil), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1)))
   #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1))))
   #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0))
   MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1))
   MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0))
   MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1))
   MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0))
   MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1)))
   MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2)))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c29(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(z2))
S tuples:
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
   MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1)))
   MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1)))
   MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2)))
K tuples:
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
   #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1))))
   #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2

Compound Symbols:   c19_2, c19_1, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c26_2, c23_1, c24_1, c30_1, c31_1, c15_1, c33_1


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

(183) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace MERGE#2(::(x0, x1), x2, x3) -> c19(#LESS(x2, x0)) by 
   MERGE#2(::(#neg(#neg(y1)), z1), #neg(#neg(y0)), z3) -> c19(#LESS(#neg(#neg(y0)), #neg(#neg(y1))))
   MERGE#2(::(#neg(#pos(y1)), z1), #neg(#pos(y0)), z3) -> c19(#LESS(#neg(#pos(y0)), #neg(#pos(y1))))
   MERGE#2(::(#neg(#s(y1)), z1), #neg(#s(y0)), z3) -> c19(#LESS(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#pos(#pos(y1)), z1), #pos(#pos(y0)), z3) -> c19(#LESS(#pos(#pos(y0)), #pos(#pos(y1))))
   MERGE#2(::(#pos(#s(y1)), z1), #pos(#s(y0)), z3) -> c19(#LESS(#pos(#s(y0)), #pos(#s(y1))))
   MERGE#2(::(#pos(#neg(#neg(y1))), z1), #pos(#neg(#neg(y0))), z3) -> c19(#LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   MERGE#2(::(#pos(#neg(#pos(y1))), z1), #pos(#neg(#pos(y0))), z3) -> c19(#LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   MERGE#2(::(#pos(#neg(#s(y1))), z1), #pos(#neg(#s(y0))), z3) -> c19(#LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   MERGE#2(::(#s(#s(y1)), z1), #s(#s(y0)), z3) -> c19(#LESS(#s(#s(y0)), #s(#s(y1))))
   MERGE#2(::(#s(#neg(#neg(y1))), z1), #s(#neg(#neg(y0))), z3) -> c19(#LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   MERGE#2(::(#s(#neg(#pos(y1))), z1), #s(#neg(#pos(y0))), z3) -> c19(#LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   MERGE#2(::(#s(#neg(#s(y1))), z1), #s(#neg(#s(y0))), z3) -> c19(#LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   MERGE#2(::(#s(#pos(#pos(y1))), z1), #s(#pos(#pos(y0))), z3) -> c19(#LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   MERGE#2(::(#s(#pos(#s(y1))), z1), #s(#pos(#s(y0))), z3) -> c19(#LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   MERGE#2(::(#s(#pos(#neg(#neg(y1)))), z1), #s(#pos(#neg(#neg(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   MERGE#2(::(#s(#pos(#neg(#pos(y1)))), z1), #s(#pos(#neg(#pos(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   MERGE#2(::(#s(#pos(#neg(#s(y1)))), z1), #s(#pos(#neg(#s(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))

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

(184)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
   MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0))
   MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c28(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, nil)) -> c28(MERGE(mergesort#1(z0), nil), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1)))
   #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1))))
   #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0))
   MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1))
   MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0))
   MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1))
   MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0))
   MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1)))
   MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2)))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c29(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(z2))
   MERGE#2(::(#neg(#neg(y1)), z1), #neg(#neg(y0)), z3) -> c19(#LESS(#neg(#neg(y0)), #neg(#neg(y1))))
   MERGE#2(::(#neg(#pos(y1)), z1), #neg(#pos(y0)), z3) -> c19(#LESS(#neg(#pos(y0)), #neg(#pos(y1))))
   MERGE#2(::(#neg(#s(y1)), z1), #neg(#s(y0)), z3) -> c19(#LESS(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#pos(#pos(y1)), z1), #pos(#pos(y0)), z3) -> c19(#LESS(#pos(#pos(y0)), #pos(#pos(y1))))
   MERGE#2(::(#pos(#s(y1)), z1), #pos(#s(y0)), z3) -> c19(#LESS(#pos(#s(y0)), #pos(#s(y1))))
   MERGE#2(::(#pos(#neg(#neg(y1))), z1), #pos(#neg(#neg(y0))), z3) -> c19(#LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   MERGE#2(::(#pos(#neg(#pos(y1))), z1), #pos(#neg(#pos(y0))), z3) -> c19(#LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   MERGE#2(::(#pos(#neg(#s(y1))), z1), #pos(#neg(#s(y0))), z3) -> c19(#LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   MERGE#2(::(#s(#s(y1)), z1), #s(#s(y0)), z3) -> c19(#LESS(#s(#s(y0)), #s(#s(y1))))
   MERGE#2(::(#s(#neg(#neg(y1))), z1), #s(#neg(#neg(y0))), z3) -> c19(#LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   MERGE#2(::(#s(#neg(#pos(y1))), z1), #s(#neg(#pos(y0))), z3) -> c19(#LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   MERGE#2(::(#s(#neg(#s(y1))), z1), #s(#neg(#s(y0))), z3) -> c19(#LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   MERGE#2(::(#s(#pos(#pos(y1))), z1), #s(#pos(#pos(y0))), z3) -> c19(#LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   MERGE#2(::(#s(#pos(#s(y1))), z1), #s(#pos(#s(y0))), z3) -> c19(#LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   MERGE#2(::(#s(#pos(#neg(#neg(y1)))), z1), #s(#pos(#neg(#neg(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   MERGE#2(::(#s(#pos(#neg(#pos(y1)))), z1), #s(#pos(#neg(#pos(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   MERGE#2(::(#s(#pos(#neg(#s(y1)))), z1), #s(#pos(#neg(#s(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))
S tuples:
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
   MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1)))
   MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1)))
   MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2)))
K tuples:
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
   #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1))))
   #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2

Compound Symbols:   c19_2, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c26_2, c23_1, c24_1, c30_1, c31_1, c15_1, c19_1, c33_1


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

(185) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1)))) by MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit#1(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
----------------------------------------

(186)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1)))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
   MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0))
   MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c28(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, nil)) -> c28(MERGE(mergesort#1(z0), nil), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1)))
   #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1))))
   #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0))
   MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1))
   MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0))
   MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1))
   MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0))
   MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1)))
   MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2)))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c29(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(z2))
   MERGE#2(::(#neg(#neg(y1)), z1), #neg(#neg(y0)), z3) -> c19(#LESS(#neg(#neg(y0)), #neg(#neg(y1))))
   MERGE#2(::(#neg(#pos(y1)), z1), #neg(#pos(y0)), z3) -> c19(#LESS(#neg(#pos(y0)), #neg(#pos(y1))))
   MERGE#2(::(#neg(#s(y1)), z1), #neg(#s(y0)), z3) -> c19(#LESS(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#pos(#pos(y1)), z1), #pos(#pos(y0)), z3) -> c19(#LESS(#pos(#pos(y0)), #pos(#pos(y1))))
   MERGE#2(::(#pos(#s(y1)), z1), #pos(#s(y0)), z3) -> c19(#LESS(#pos(#s(y0)), #pos(#s(y1))))
   MERGE#2(::(#pos(#neg(#neg(y1))), z1), #pos(#neg(#neg(y0))), z3) -> c19(#LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   MERGE#2(::(#pos(#neg(#pos(y1))), z1), #pos(#neg(#pos(y0))), z3) -> c19(#LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   MERGE#2(::(#pos(#neg(#s(y1))), z1), #pos(#neg(#s(y0))), z3) -> c19(#LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   MERGE#2(::(#s(#s(y1)), z1), #s(#s(y0)), z3) -> c19(#LESS(#s(#s(y0)), #s(#s(y1))))
   MERGE#2(::(#s(#neg(#neg(y1))), z1), #s(#neg(#neg(y0))), z3) -> c19(#LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   MERGE#2(::(#s(#neg(#pos(y1))), z1), #s(#neg(#pos(y0))), z3) -> c19(#LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   MERGE#2(::(#s(#neg(#s(y1))), z1), #s(#neg(#s(y0))), z3) -> c19(#LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   MERGE#2(::(#s(#pos(#pos(y1))), z1), #s(#pos(#pos(y0))), z3) -> c19(#LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   MERGE#2(::(#s(#pos(#s(y1))), z1), #s(#pos(#s(y0))), z3) -> c19(#LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   MERGE#2(::(#s(#pos(#neg(#neg(y1)))), z1), #s(#pos(#neg(#neg(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   MERGE#2(::(#s(#pos(#neg(#pos(y1)))), z1), #s(#pos(#neg(#pos(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   MERGE#2(::(#s(#pos(#neg(#s(y1)))), z1), #s(#pos(#neg(#s(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit#1(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
S tuples:
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
   MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1)))
   MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1)))
   MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2)))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit#1(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
K tuples:
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
   #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1))))
   #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2

Compound Symbols:   c19_2, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c23_1, c24_1, c30_1, c31_1, c15_1, c19_1, c33_1, c26_2


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

(187) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace #COMPARE(#neg(#neg(y1)), #neg(#neg(y0))) -> c8(#COMPARE(#neg(y0), #neg(y1))) by 
   #COMPARE(#neg(#neg(#neg(y1))), #neg(#neg(#neg(y0)))) -> c8(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#neg(#neg(#pos(y1))), #neg(#neg(#pos(y0)))) -> c8(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#neg(#neg(#s(y1))), #neg(#neg(#s(y0)))) -> c8(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))

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

(188)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
   MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0))
   MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c28(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, nil)) -> c28(MERGE(mergesort#1(z0), nil), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1)))
   #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1))))
   #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0))
   MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1))
   MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0))
   MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1))
   MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0))
   MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1)))
   MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2)))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c29(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(z2))
   MERGE#2(::(#neg(#neg(y1)), z1), #neg(#neg(y0)), z3) -> c19(#LESS(#neg(#neg(y0)), #neg(#neg(y1))))
   MERGE#2(::(#neg(#pos(y1)), z1), #neg(#pos(y0)), z3) -> c19(#LESS(#neg(#pos(y0)), #neg(#pos(y1))))
   MERGE#2(::(#neg(#s(y1)), z1), #neg(#s(y0)), z3) -> c19(#LESS(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#pos(#pos(y1)), z1), #pos(#pos(y0)), z3) -> c19(#LESS(#pos(#pos(y0)), #pos(#pos(y1))))
   MERGE#2(::(#pos(#s(y1)), z1), #pos(#s(y0)), z3) -> c19(#LESS(#pos(#s(y0)), #pos(#s(y1))))
   MERGE#2(::(#pos(#neg(#neg(y1))), z1), #pos(#neg(#neg(y0))), z3) -> c19(#LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   MERGE#2(::(#pos(#neg(#pos(y1))), z1), #pos(#neg(#pos(y0))), z3) -> c19(#LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   MERGE#2(::(#pos(#neg(#s(y1))), z1), #pos(#neg(#s(y0))), z3) -> c19(#LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   MERGE#2(::(#s(#s(y1)), z1), #s(#s(y0)), z3) -> c19(#LESS(#s(#s(y0)), #s(#s(y1))))
   MERGE#2(::(#s(#neg(#neg(y1))), z1), #s(#neg(#neg(y0))), z3) -> c19(#LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   MERGE#2(::(#s(#neg(#pos(y1))), z1), #s(#neg(#pos(y0))), z3) -> c19(#LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   MERGE#2(::(#s(#neg(#s(y1))), z1), #s(#neg(#s(y0))), z3) -> c19(#LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   MERGE#2(::(#s(#pos(#pos(y1))), z1), #s(#pos(#pos(y0))), z3) -> c19(#LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   MERGE#2(::(#s(#pos(#s(y1))), z1), #s(#pos(#s(y0))), z3) -> c19(#LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   MERGE#2(::(#s(#pos(#neg(#neg(y1)))), z1), #s(#pos(#neg(#neg(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   MERGE#2(::(#s(#pos(#neg(#pos(y1)))), z1), #s(#pos(#neg(#pos(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   MERGE#2(::(#s(#pos(#neg(#s(y1)))), z1), #s(#pos(#neg(#s(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit#1(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   #COMPARE(#neg(#neg(#neg(y1))), #neg(#neg(#neg(y0)))) -> c8(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#neg(#neg(#pos(y1))), #neg(#neg(#pos(y0)))) -> c8(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#neg(#neg(#s(y1))), #neg(#neg(#s(y0)))) -> c8(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
S tuples:
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
   MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1)))
   MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1)))
   MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2)))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit#1(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
K tuples:
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
   #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1))))
   #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2

Compound Symbols:   c19_2, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c23_1, c24_1, c30_1, c31_1, c15_1, c19_1, c33_1, c26_2


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

(189) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil)) by MERGESORT#3(tuple#2(z0, nil)) -> c29(MERGE(mergesort#1(z0), nil))
----------------------------------------

(190)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
   MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0))
   MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c28(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, nil)) -> c28(MERGE(mergesort#1(z0), nil), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1)))
   #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1))))
   #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0))
   MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1))
   MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0))
   MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1))
   MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0))
   MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1)))
   MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2)))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c29(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(z2))
   MERGE#2(::(#neg(#neg(y1)), z1), #neg(#neg(y0)), z3) -> c19(#LESS(#neg(#neg(y0)), #neg(#neg(y1))))
   MERGE#2(::(#neg(#pos(y1)), z1), #neg(#pos(y0)), z3) -> c19(#LESS(#neg(#pos(y0)), #neg(#pos(y1))))
   MERGE#2(::(#neg(#s(y1)), z1), #neg(#s(y0)), z3) -> c19(#LESS(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#pos(#pos(y1)), z1), #pos(#pos(y0)), z3) -> c19(#LESS(#pos(#pos(y0)), #pos(#pos(y1))))
   MERGE#2(::(#pos(#s(y1)), z1), #pos(#s(y0)), z3) -> c19(#LESS(#pos(#s(y0)), #pos(#s(y1))))
   MERGE#2(::(#pos(#neg(#neg(y1))), z1), #pos(#neg(#neg(y0))), z3) -> c19(#LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   MERGE#2(::(#pos(#neg(#pos(y1))), z1), #pos(#neg(#pos(y0))), z3) -> c19(#LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   MERGE#2(::(#pos(#neg(#s(y1))), z1), #pos(#neg(#s(y0))), z3) -> c19(#LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   MERGE#2(::(#s(#s(y1)), z1), #s(#s(y0)), z3) -> c19(#LESS(#s(#s(y0)), #s(#s(y1))))
   MERGE#2(::(#s(#neg(#neg(y1))), z1), #s(#neg(#neg(y0))), z3) -> c19(#LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   MERGE#2(::(#s(#neg(#pos(y1))), z1), #s(#neg(#pos(y0))), z3) -> c19(#LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   MERGE#2(::(#s(#neg(#s(y1))), z1), #s(#neg(#s(y0))), z3) -> c19(#LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   MERGE#2(::(#s(#pos(#pos(y1))), z1), #s(#pos(#pos(y0))), z3) -> c19(#LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   MERGE#2(::(#s(#pos(#s(y1))), z1), #s(#pos(#s(y0))), z3) -> c19(#LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   MERGE#2(::(#s(#pos(#neg(#neg(y1)))), z1), #s(#pos(#neg(#neg(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   MERGE#2(::(#s(#pos(#neg(#pos(y1)))), z1), #s(#pos(#neg(#pos(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   MERGE#2(::(#s(#pos(#neg(#s(y1)))), z1), #s(#pos(#neg(#s(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit#1(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   #COMPARE(#neg(#neg(#neg(y1))), #neg(#neg(#neg(y0)))) -> c8(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#neg(#neg(#pos(y1))), #neg(#neg(#pos(y0)))) -> c8(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#neg(#neg(#s(y1))), #neg(#neg(#s(y0)))) -> c8(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGESORT#3(tuple#2(z0, nil)) -> c29(MERGE(mergesort#1(z0), nil))
S tuples:
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
   MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1)))
   MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1)))
   MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2)))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit#1(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
K tuples:
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
   #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1))))
   #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2

Compound Symbols:   c19_2, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c23_1, c24_1, c30_1, c31_1, c15_1, c19_1, c33_1, c26_2


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

(191) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace #COMPARE(#neg(#pos(y1)), #neg(#pos(y0))) -> c8(#COMPARE(#pos(y0), #pos(y1))) by 
   #COMPARE(#neg(#pos(#pos(y1))), #neg(#pos(#pos(y0)))) -> c8(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #COMPARE(#neg(#pos(#s(y1))), #neg(#pos(#s(y0)))) -> c8(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #COMPARE(#neg(#pos(#neg(#neg(y1)))), #neg(#pos(#neg(#neg(y0))))) -> c8(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #COMPARE(#neg(#pos(#neg(#pos(y1)))), #neg(#pos(#neg(#pos(y0))))) -> c8(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #COMPARE(#neg(#pos(#neg(#s(y1)))), #neg(#pos(#neg(#s(y0))))) -> c8(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))

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

(192)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
   MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0))
   MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c28(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, nil)) -> c28(MERGE(mergesort#1(z0), nil), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1)))
   #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1))))
   #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0))
   MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1))
   MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0))
   MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1))
   MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0))
   MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1)))
   MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2)))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c29(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(z2))
   MERGE#2(::(#neg(#neg(y1)), z1), #neg(#neg(y0)), z3) -> c19(#LESS(#neg(#neg(y0)), #neg(#neg(y1))))
   MERGE#2(::(#neg(#pos(y1)), z1), #neg(#pos(y0)), z3) -> c19(#LESS(#neg(#pos(y0)), #neg(#pos(y1))))
   MERGE#2(::(#neg(#s(y1)), z1), #neg(#s(y0)), z3) -> c19(#LESS(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#pos(#pos(y1)), z1), #pos(#pos(y0)), z3) -> c19(#LESS(#pos(#pos(y0)), #pos(#pos(y1))))
   MERGE#2(::(#pos(#s(y1)), z1), #pos(#s(y0)), z3) -> c19(#LESS(#pos(#s(y0)), #pos(#s(y1))))
   MERGE#2(::(#pos(#neg(#neg(y1))), z1), #pos(#neg(#neg(y0))), z3) -> c19(#LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   MERGE#2(::(#pos(#neg(#pos(y1))), z1), #pos(#neg(#pos(y0))), z3) -> c19(#LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   MERGE#2(::(#pos(#neg(#s(y1))), z1), #pos(#neg(#s(y0))), z3) -> c19(#LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   MERGE#2(::(#s(#s(y1)), z1), #s(#s(y0)), z3) -> c19(#LESS(#s(#s(y0)), #s(#s(y1))))
   MERGE#2(::(#s(#neg(#neg(y1))), z1), #s(#neg(#neg(y0))), z3) -> c19(#LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   MERGE#2(::(#s(#neg(#pos(y1))), z1), #s(#neg(#pos(y0))), z3) -> c19(#LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   MERGE#2(::(#s(#neg(#s(y1))), z1), #s(#neg(#s(y0))), z3) -> c19(#LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   MERGE#2(::(#s(#pos(#pos(y1))), z1), #s(#pos(#pos(y0))), z3) -> c19(#LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   MERGE#2(::(#s(#pos(#s(y1))), z1), #s(#pos(#s(y0))), z3) -> c19(#LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   MERGE#2(::(#s(#pos(#neg(#neg(y1)))), z1), #s(#pos(#neg(#neg(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   MERGE#2(::(#s(#pos(#neg(#pos(y1)))), z1), #s(#pos(#neg(#pos(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   MERGE#2(::(#s(#pos(#neg(#s(y1)))), z1), #s(#pos(#neg(#s(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit#1(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   #COMPARE(#neg(#neg(#neg(y1))), #neg(#neg(#neg(y0)))) -> c8(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#neg(#neg(#pos(y1))), #neg(#neg(#pos(y0)))) -> c8(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#neg(#neg(#s(y1))), #neg(#neg(#s(y0)))) -> c8(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGESORT#3(tuple#2(z0, nil)) -> c29(MERGE(mergesort#1(z0), nil))
   #COMPARE(#neg(#pos(#pos(y1))), #neg(#pos(#pos(y0)))) -> c8(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #COMPARE(#neg(#pos(#s(y1))), #neg(#pos(#s(y0)))) -> c8(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #COMPARE(#neg(#pos(#neg(#neg(y1)))), #neg(#pos(#neg(#neg(y0))))) -> c8(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #COMPARE(#neg(#pos(#neg(#pos(y1)))), #neg(#pos(#neg(#pos(y0))))) -> c8(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #COMPARE(#neg(#pos(#neg(#s(y1)))), #neg(#pos(#neg(#s(y0))))) -> c8(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
S tuples:
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
   MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1)))
   MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1)))
   MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2)))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit#1(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
K tuples:
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
   #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1))))
   #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2

Compound Symbols:   c19_2, c26_1, c28_2, c29_2, c8_1, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c23_1, c24_1, c30_1, c31_1, c15_1, c19_1, c33_1, c26_2


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

(193) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace #COMPARE(#neg(#s(y1)), #neg(#s(y0))) -> c8(#COMPARE(#s(y0), #s(y1))) by 
   #COMPARE(#neg(#s(#s(y1))), #neg(#s(#s(y0)))) -> c8(#COMPARE(#s(#s(y0)), #s(#s(y1))))
   #COMPARE(#neg(#s(#neg(#neg(y1)))), #neg(#s(#neg(#neg(y0))))) -> c8(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   #COMPARE(#neg(#s(#neg(#pos(y1)))), #neg(#s(#neg(#pos(y0))))) -> c8(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   #COMPARE(#neg(#s(#neg(#s(y1)))), #neg(#s(#neg(#s(y0))))) -> c8(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   #COMPARE(#neg(#s(#pos(#pos(y1)))), #neg(#s(#pos(#pos(y0))))) -> c8(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   #COMPARE(#neg(#s(#pos(#s(y1)))), #neg(#s(#pos(#s(y0))))) -> c8(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   #COMPARE(#neg(#s(#pos(#neg(#neg(y1))))), #neg(#s(#pos(#neg(#neg(y0)))))) -> c8(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   #COMPARE(#neg(#s(#pos(#neg(#pos(y1))))), #neg(#s(#pos(#neg(#pos(y0)))))) -> c8(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   #COMPARE(#neg(#s(#pos(#neg(#s(y1))))), #neg(#s(#pos(#neg(#s(y0)))))) -> c8(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))

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

(194)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1)))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
   MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0))
   MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c28(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, nil)) -> c28(MERGE(mergesort#1(z0), nil), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1)))
   #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1))))
   #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0))
   MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1))
   MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0))
   MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1))
   MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0))
   MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1)))
   MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2)))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c29(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(z2))
   MERGE#2(::(#neg(#neg(y1)), z1), #neg(#neg(y0)), z3) -> c19(#LESS(#neg(#neg(y0)), #neg(#neg(y1))))
   MERGE#2(::(#neg(#pos(y1)), z1), #neg(#pos(y0)), z3) -> c19(#LESS(#neg(#pos(y0)), #neg(#pos(y1))))
   MERGE#2(::(#neg(#s(y1)), z1), #neg(#s(y0)), z3) -> c19(#LESS(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#pos(#pos(y1)), z1), #pos(#pos(y0)), z3) -> c19(#LESS(#pos(#pos(y0)), #pos(#pos(y1))))
   MERGE#2(::(#pos(#s(y1)), z1), #pos(#s(y0)), z3) -> c19(#LESS(#pos(#s(y0)), #pos(#s(y1))))
   MERGE#2(::(#pos(#neg(#neg(y1))), z1), #pos(#neg(#neg(y0))), z3) -> c19(#LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   MERGE#2(::(#pos(#neg(#pos(y1))), z1), #pos(#neg(#pos(y0))), z3) -> c19(#LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   MERGE#2(::(#pos(#neg(#s(y1))), z1), #pos(#neg(#s(y0))), z3) -> c19(#LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   MERGE#2(::(#s(#s(y1)), z1), #s(#s(y0)), z3) -> c19(#LESS(#s(#s(y0)), #s(#s(y1))))
   MERGE#2(::(#s(#neg(#neg(y1))), z1), #s(#neg(#neg(y0))), z3) -> c19(#LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   MERGE#2(::(#s(#neg(#pos(y1))), z1), #s(#neg(#pos(y0))), z3) -> c19(#LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   MERGE#2(::(#s(#neg(#s(y1))), z1), #s(#neg(#s(y0))), z3) -> c19(#LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   MERGE#2(::(#s(#pos(#pos(y1))), z1), #s(#pos(#pos(y0))), z3) -> c19(#LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   MERGE#2(::(#s(#pos(#s(y1))), z1), #s(#pos(#s(y0))), z3) -> c19(#LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   MERGE#2(::(#s(#pos(#neg(#neg(y1)))), z1), #s(#pos(#neg(#neg(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   MERGE#2(::(#s(#pos(#neg(#pos(y1)))), z1), #s(#pos(#neg(#pos(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   MERGE#2(::(#s(#pos(#neg(#s(y1)))), z1), #s(#pos(#neg(#s(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit#1(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   #COMPARE(#neg(#neg(#neg(y1))), #neg(#neg(#neg(y0)))) -> c8(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#neg(#neg(#pos(y1))), #neg(#neg(#pos(y0)))) -> c8(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#neg(#neg(#s(y1))), #neg(#neg(#s(y0)))) -> c8(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGESORT#3(tuple#2(z0, nil)) -> c29(MERGE(mergesort#1(z0), nil))
   #COMPARE(#neg(#pos(#pos(y1))), #neg(#pos(#pos(y0)))) -> c8(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #COMPARE(#neg(#pos(#s(y1))), #neg(#pos(#s(y0)))) -> c8(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #COMPARE(#neg(#pos(#neg(#neg(y1)))), #neg(#pos(#neg(#neg(y0))))) -> c8(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #COMPARE(#neg(#pos(#neg(#pos(y1)))), #neg(#pos(#neg(#pos(y0))))) -> c8(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #COMPARE(#neg(#pos(#neg(#s(y1)))), #neg(#pos(#neg(#s(y0))))) -> c8(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   #COMPARE(#neg(#s(#s(y1))), #neg(#s(#s(y0)))) -> c8(#COMPARE(#s(#s(y0)), #s(#s(y1))))
   #COMPARE(#neg(#s(#neg(#neg(y1)))), #neg(#s(#neg(#neg(y0))))) -> c8(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   #COMPARE(#neg(#s(#neg(#pos(y1)))), #neg(#s(#neg(#pos(y0))))) -> c8(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   #COMPARE(#neg(#s(#neg(#s(y1)))), #neg(#s(#neg(#s(y0))))) -> c8(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   #COMPARE(#neg(#s(#pos(#pos(y1)))), #neg(#s(#pos(#pos(y0))))) -> c8(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   #COMPARE(#neg(#s(#pos(#s(y1)))), #neg(#s(#pos(#s(y0))))) -> c8(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   #COMPARE(#neg(#s(#pos(#neg(#neg(y1))))), #neg(#s(#pos(#neg(#neg(y0)))))) -> c8(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   #COMPARE(#neg(#s(#pos(#neg(#pos(y1))))), #neg(#s(#pos(#neg(#pos(y0)))))) -> c8(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   #COMPARE(#neg(#s(#pos(#neg(#s(y1))))), #neg(#s(#pos(#neg(#s(y0)))))) -> c8(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))
S tuples:
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
   MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1)))
   MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1)))
   MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2)))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit#1(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
K tuples:
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
   #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1))))
   #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2

Compound Symbols:   c19_2, c26_1, c28_2, c29_2, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c23_1, c24_1, c30_1, c31_1, c15_1, c19_1, c33_1, c26_2, c8_1


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

(195) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace #COMPARE(#pos(#pos(y0)), #pos(#pos(y1))) -> c12(#COMPARE(#pos(y0), #pos(y1))) by 
   #COMPARE(#pos(#pos(#pos(y0))), #pos(#pos(#pos(y1)))) -> c12(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #COMPARE(#pos(#pos(#s(y0))), #pos(#pos(#s(y1)))) -> c12(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #COMPARE(#pos(#pos(#neg(#neg(y0)))), #pos(#pos(#neg(#neg(y1))))) -> c12(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #COMPARE(#pos(#pos(#neg(#pos(y0)))), #pos(#pos(#neg(#pos(y1))))) -> c12(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #COMPARE(#pos(#pos(#neg(#s(y0)))), #pos(#pos(#neg(#s(y1))))) -> c12(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))

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

(196)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   #cklt(#EQ) -> #false
   #cklt(#GT) -> #false
   #cklt(#LT) -> #true
   #compare(#0, #0) -> #EQ
   #compare(#0, #neg(z0)) -> #GT
   #compare(#0, #pos(z0)) -> #LT
   #compare(#0, #s(z0)) -> #LT
   #compare(#neg(z0), #0) -> #LT
   #compare(#neg(z0), #neg(z1)) -> #compare(z1, z0)
   #compare(#neg(z0), #pos(z1)) -> #LT
   #compare(#pos(z0), #0) -> #GT
   #compare(#pos(z0), #neg(z1)) -> #GT
   #compare(#pos(z0), #pos(z1)) -> #compare(z0, z1)
   #compare(#s(z0), #0) -> #GT
   #compare(#s(z0), #s(z1)) -> #compare(z0, z1)
   #less(z0, z1) -> #cklt(#compare(z0, z1))
   merge(z0, z1) -> merge#1(z0, z1)
   merge#1(::(z0, z1), z2) -> merge#2(z2, z0, z1)
   merge#1(nil, z0) -> z0
   merge#2(::(z0, z1), z2, z3) -> merge#3(#less(z2, z0), z2, z3, z0, z1)
   merge#2(nil, z0, z1) -> ::(z0, z1)
   merge#3(#false, z0, z1, z2, z3) -> ::(z2, merge(::(z0, z1), z3))
   merge#3(#true, z0, z1, z2, z3) -> ::(z0, merge(z1, ::(z2, z3)))
   mergesort(z0) -> mergesort#1(z0)
   mergesort#1(::(z0, z1)) -> mergesort#2(z1, z0)
   mergesort#1(nil) -> nil
   mergesort#2(::(z0, z1), z2) -> mergesort#3(msplit(::(z2, ::(z0, z1))))
   mergesort#2(nil, z0) -> ::(z0, nil)
   mergesort#3(tuple#2(z0, z1)) -> merge(mergesort(z0), mergesort(z1))
   msplit(z0) -> msplit#1(z0)
   msplit#1(::(z0, z1)) -> msplit#2(z1, z0)
   msplit#1(nil) -> tuple#2(nil, nil)
   msplit#2(::(z0, z1), z2) -> msplit#3(msplit(z1), z2, z0)
   msplit#2(nil, z0) -> tuple#2(::(z0, nil), nil)
   msplit#3(tuple#2(z0, z1), z2, z3) -> tuple#2(::(z2, z0), ::(z3, z1))
Tuples:
   MERGE#2(::(#neg(z1), x1), #neg(z0), x3) -> c19(MERGE#3(#cklt(#compare(z1, z0)), #neg(z0), x3, #neg(z1), x1), #LESS(#neg(z0), #neg(z1)))
   MERGE#2(::(#pos(z1), x1), #pos(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #pos(z0), x3, #pos(z1), x1), #LESS(#pos(z0), #pos(z1)))
   MERGE#2(::(#s(z1), x1), #s(z0), x3) -> c19(MERGE#3(#cklt(#compare(z0, z1)), #s(z0), x3, #s(z1), x1), #LESS(#s(z0), #s(z1)))
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   #COMPARE(#pos(#s(y0)), #pos(#s(y1))) -> c12(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c12(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c12(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c12(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   #COMPARE(#s(#s(y0)), #s(#s(y1))) -> c14(#COMPARE(#s(y0), #s(y1)))
   #COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c14(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c14(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c14(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c14(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c14(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c14(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c14(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c14(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
   MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0))
   MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c28(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, nil)) -> c28(MERGE(mergesort#1(z0), nil), MERGESORT(z0))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1)))
   #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1))))
   #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))
   MERGE#2(::(#0, z0), #0, z1) -> c19(MERGE#3(#false, #0, z1, #0, z0))
   MERGE#2(::(#neg(z0), z1), #0, z2) -> c19(MERGE#3(#false, #0, z2, #neg(z0), z1))
   MERGE#2(::(#pos(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #pos(z0), z1))
   MERGE#2(::(#s(z0), z1), #0, z2) -> c19(MERGE#3(#true, #0, z2, #s(z0), z1))
   MERGE#2(::(#0, z0), #neg(z1), z2) -> c19(MERGE#3(#true, #neg(z1), z2, #0, z0))
   MERGE#2(::(#pos(z0), z1), #neg(z2), z3) -> c19(MERGE#3(#true, #neg(z2), z3, #pos(z0), z1))
   MERGE#2(::(#0, z0), #pos(z1), z2) -> c19(MERGE#3(#false, #pos(z1), z2, #0, z0))
   MERGE#2(::(#neg(z0), z1), #pos(z2), z3) -> c19(MERGE#3(#false, #pos(z2), z3, #neg(z0), z1))
   MERGE#2(::(#0, x0), #s(x1), x2) -> c19(MERGE#3(#false, #s(x1), x2, #0, x0))
   MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1)))
   MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2)))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c29(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(z2))
   MERGE#2(::(#neg(#neg(y1)), z1), #neg(#neg(y0)), z3) -> c19(#LESS(#neg(#neg(y0)), #neg(#neg(y1))))
   MERGE#2(::(#neg(#pos(y1)), z1), #neg(#pos(y0)), z3) -> c19(#LESS(#neg(#pos(y0)), #neg(#pos(y1))))
   MERGE#2(::(#neg(#s(y1)), z1), #neg(#s(y0)), z3) -> c19(#LESS(#neg(#s(y0)), #neg(#s(y1))))
   MERGE#2(::(#pos(#pos(y1)), z1), #pos(#pos(y0)), z3) -> c19(#LESS(#pos(#pos(y0)), #pos(#pos(y1))))
   MERGE#2(::(#pos(#s(y1)), z1), #pos(#s(y0)), z3) -> c19(#LESS(#pos(#s(y0)), #pos(#s(y1))))
   MERGE#2(::(#pos(#neg(#neg(y1))), z1), #pos(#neg(#neg(y0))), z3) -> c19(#LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   MERGE#2(::(#pos(#neg(#pos(y1))), z1), #pos(#neg(#pos(y0))), z3) -> c19(#LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   MERGE#2(::(#pos(#neg(#s(y1))), z1), #pos(#neg(#s(y0))), z3) -> c19(#LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   MERGE#2(::(#s(#s(y1)), z1), #s(#s(y0)), z3) -> c19(#LESS(#s(#s(y0)), #s(#s(y1))))
   MERGE#2(::(#s(#neg(#neg(y1))), z1), #s(#neg(#neg(y0))), z3) -> c19(#LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   MERGE#2(::(#s(#neg(#pos(y1))), z1), #s(#neg(#pos(y0))), z3) -> c19(#LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   MERGE#2(::(#s(#neg(#s(y1))), z1), #s(#neg(#s(y0))), z3) -> c19(#LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   MERGE#2(::(#s(#pos(#pos(y1))), z1), #s(#pos(#pos(y0))), z3) -> c19(#LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   MERGE#2(::(#s(#pos(#s(y1))), z1), #s(#pos(#s(y0))), z3) -> c19(#LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   MERGE#2(::(#s(#pos(#neg(#neg(y1)))), z1), #s(#pos(#neg(#neg(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   MERGE#2(::(#s(#pos(#neg(#pos(y1)))), z1), #s(#pos(#neg(#pos(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   MERGE#2(::(#s(#pos(#neg(#s(y1)))), z1), #s(#pos(#neg(#s(y0)))), z3) -> c19(#LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit#1(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
   #COMPARE(#neg(#neg(#neg(y1))), #neg(#neg(#neg(y0)))) -> c8(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #COMPARE(#neg(#neg(#pos(y1))), #neg(#neg(#pos(y0)))) -> c8(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #COMPARE(#neg(#neg(#s(y1))), #neg(#neg(#s(y0)))) -> c8(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   MERGESORT#3(tuple#2(z0, nil)) -> c29(MERGE(mergesort#1(z0), nil))
   #COMPARE(#neg(#pos(#pos(y1))), #neg(#pos(#pos(y0)))) -> c8(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #COMPARE(#neg(#pos(#s(y1))), #neg(#pos(#s(y0)))) -> c8(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #COMPARE(#neg(#pos(#neg(#neg(y1)))), #neg(#pos(#neg(#neg(y0))))) -> c8(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #COMPARE(#neg(#pos(#neg(#pos(y1)))), #neg(#pos(#neg(#pos(y0))))) -> c8(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #COMPARE(#neg(#pos(#neg(#s(y1)))), #neg(#pos(#neg(#s(y0))))) -> c8(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   #COMPARE(#neg(#s(#s(y1))), #neg(#s(#s(y0)))) -> c8(#COMPARE(#s(#s(y0)), #s(#s(y1))))
   #COMPARE(#neg(#s(#neg(#neg(y1)))), #neg(#s(#neg(#neg(y0))))) -> c8(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   #COMPARE(#neg(#s(#neg(#pos(y1)))), #neg(#s(#neg(#pos(y0))))) -> c8(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   #COMPARE(#neg(#s(#neg(#s(y1)))), #neg(#s(#neg(#s(y0))))) -> c8(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   #COMPARE(#neg(#s(#pos(#pos(y1)))), #neg(#s(#pos(#pos(y0))))) -> c8(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   #COMPARE(#neg(#s(#pos(#s(y1)))), #neg(#s(#pos(#s(y0))))) -> c8(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   #COMPARE(#neg(#s(#pos(#neg(#neg(y1))))), #neg(#s(#pos(#neg(#neg(y0)))))) -> c8(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   #COMPARE(#neg(#s(#pos(#neg(#pos(y1))))), #neg(#s(#pos(#neg(#pos(y0)))))) -> c8(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   #COMPARE(#neg(#s(#pos(#neg(#s(y1))))), #neg(#s(#pos(#neg(#s(y0)))))) -> c8(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))
   #COMPARE(#pos(#pos(#pos(y0))), #pos(#pos(#pos(y1)))) -> c12(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #COMPARE(#pos(#pos(#s(y0))), #pos(#pos(#s(y1)))) -> c12(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #COMPARE(#pos(#pos(#neg(#neg(y0)))), #pos(#pos(#neg(#neg(y1))))) -> c12(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #COMPARE(#pos(#pos(#neg(#pos(y0)))), #pos(#pos(#neg(#pos(y1))))) -> c12(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #COMPARE(#pos(#pos(#neg(#s(y0)))), #pos(#pos(#neg(#s(y1))))) -> c12(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
S tuples:
   MERGESORT#3(tuple#2(z0, x1)) -> c28(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(z0))
   MERGESORT#3(tuple#2(z0, x1)) -> c29(MERGE(mergesort#1(z0), mergesort#1(x1)), MERGESORT(x1))
   MERGE(::(y0, y1), z1) -> c16(MERGE#1(::(y0, y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y2), z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #s(y2), z1))
   MERGE#1(::(z0, z1), ::(y0, y1)) -> c17(MERGE#2(::(y0, y1), z0, z1))
   MERGE#1(::(#0, z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #0, z1))
   MERGE#1(::(#0, z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #0, z1))
   MERGE#1(::(#0, z1), ::(#s(y0), y1)) -> c17(MERGE#2(::(#s(y0), y1), #0, z1))
   MERGE#1(::(#neg(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #neg(y1), z1))
   MERGE#1(::(#neg(y2), z1), ::(#pos(y0), y1)) -> c17(MERGE#2(::(#pos(y0), y1), #neg(y2), z1))
   MERGE#1(::(#pos(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #pos(y1), z1))
   MERGE#1(::(#pos(y2), z1), ::(#neg(y0), y1)) -> c17(MERGE#2(::(#neg(y0), y1), #pos(y2), z1))
   MERGE#1(::(#s(y1), z1), ::(#0, y0)) -> c17(MERGE#2(::(#0, y0), #s(y1), z1))
   MERGESORT(::(y0, y1)) -> c23(MERGESORT#1(::(y0, y1)))
   MERGESORT#1(::(z0, ::(y0, y1))) -> c24(MERGESORT#2(::(y0, y1), z0))
   MSPLIT(::(y0, y1)) -> c30(MSPLIT#1(::(y0, y1)))
   MSPLIT#1(::(z0, ::(y0, y1))) -> c31(MSPLIT#2(::(y0, y1), z0))
   MERGESORT#3(tuple#2(::(z0, z1), z2)) -> c28(MERGE(mergesort#2(z1, z0), mergesort#1(z2)), MERGESORT(::(z0, z1)))
   MSPLIT#2(::(z0, ::(y0, y1)), z2) -> c33(MSPLIT(::(y0, y1)))
   MERGESORT#3(tuple#2(z0, ::(z1, z2))) -> c29(MERGE(mergesort#1(z0), mergesort#2(z2, z1)), MERGESORT(::(z1, z2)))
   MERGESORT#2(::(z0, z1), z2) -> c26(MERGESORT#3(msplit#3(msplit#1(z1), z2, z0)), MSPLIT(::(z2, ::(z0, z1))))
K tuples:
   MERGESORT#2(::(x0, x1), x2) -> c26(MSPLIT(::(x2, ::(x0, x1))))
   MERGESORT#3(tuple#2(x0, nil)) -> c28(MERGE(mergesort(x0), nil), MERGESORT(x0))
   MERGESORT#3(tuple#2(x0, ::(z0, z1))) -> c28(MERGE(mergesort(x0), mergesort#2(z1, z0)), MERGESORT(x0))
   MERGESORT#3(tuple#2(::(z0, z1), x1)) -> c29(MERGE(mergesort#2(z1, z0), mergesort(x1)), MERGESORT(x1))
   MERGE#3(#false, #neg(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#neg(x2), x3), x1))
   MERGE#3(#false, #pos(x2), x3, #pos(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#false, #s(x1), x2, #0, x0) -> c21(MERGE(::(#s(x1), x2), x0))
   MERGE#3(#false, #s(x2), x3, #s(x0), x1) -> c21(MERGE(::(#s(x2), x3), x1))
   MERGE#3(#false, #0, x1, #0, x0) -> c21(MERGE(::(#0, x1), x0))
   MERGE#3(#false, #0, x2, #neg(x0), x1) -> c21(MERGE(::(#0, x2), x1))
   MERGE#3(#false, #pos(x1), x2, #0, x0) -> c21(MERGE(::(#pos(x1), x2), x0))
   MERGE#3(#false, #pos(x2), x3, #neg(x0), x1) -> c21(MERGE(::(#pos(x2), x3), x1))
   MERGE#3(#true, #neg(x2), x3, #neg(x0), x1) -> c22(MERGE(x3, ::(#neg(x0), x1)))
   MERGE#3(#true, #pos(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGE#3(#true, #s(x2), x3, #s(x0), x1) -> c22(MERGE(x3, ::(#s(x0), x1)))
   MERGE#3(#true, #0, x2, #pos(x0), x1) -> c22(MERGE(x2, ::(#pos(x0), x1)))
   MERGE#3(#true, #0, x2, #s(x0), x1) -> c22(MERGE(x2, ::(#s(x0), x1)))
   MERGE#3(#true, #neg(x1), x2, #0, x0) -> c22(MERGE(x2, ::(#0, x0)))
   MERGE#3(#true, #neg(x2), x3, #pos(x0), x1) -> c22(MERGE(x3, ::(#pos(x0), x1)))
   MERGESORT#3(tuple#2(nil, x1)) -> c29(MERGESORT(x1))
   MERGESORT#3(tuple#2(x0, nil)) -> c29(MERGE(mergesort(x0), nil))
   #LESS(#neg(#neg(y0)), #neg(#neg(y1))) -> c15(#COMPARE(#neg(#neg(y0)), #neg(#neg(y1))))
   #LESS(#neg(#pos(y0)), #neg(#pos(y1))) -> c15(#COMPARE(#neg(#pos(y0)), #neg(#pos(y1))))
   #LESS(#neg(#s(y0)), #neg(#s(y1))) -> c15(#COMPARE(#neg(#s(y0)), #neg(#s(y1))))
   #LESS(#pos(#pos(y0)), #pos(#pos(y1))) -> c15(#COMPARE(#pos(#pos(y0)), #pos(#pos(y1))))
   #LESS(#pos(#s(y0)), #pos(#s(y1))) -> c15(#COMPARE(#pos(#s(y0)), #pos(#s(y1))))
   #LESS(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))) -> c15(#COMPARE(#pos(#neg(#neg(y0))), #pos(#neg(#neg(y1)))))
   #LESS(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))) -> c15(#COMPARE(#pos(#neg(#pos(y0))), #pos(#neg(#pos(y1)))))
   #LESS(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))) -> c15(#COMPARE(#pos(#neg(#s(y0))), #pos(#neg(#s(y1)))))
   #LESS(#s(#s(y0)), #s(#s(y1))) -> c15(#COMPARE(#s(#s(y0)), #s(#s(y1))))
   #LESS(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))) -> c15(#COMPARE(#s(#neg(#neg(y0))), #s(#neg(#neg(y1)))))
   #LESS(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))) -> c15(#COMPARE(#s(#neg(#pos(y0))), #s(#neg(#pos(y1)))))
   #LESS(#s(#neg(#s(y0))), #s(#neg(#s(y1)))) -> c15(#COMPARE(#s(#neg(#s(y0))), #s(#neg(#s(y1)))))
   #LESS(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))) -> c15(#COMPARE(#s(#pos(#pos(y0))), #s(#pos(#pos(y1)))))
   #LESS(#s(#pos(#s(y0))), #s(#pos(#s(y1)))) -> c15(#COMPARE(#s(#pos(#s(y0))), #s(#pos(#s(y1)))))
   #LESS(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#neg(y0)))), #s(#pos(#neg(#neg(y1))))))
   #LESS(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#pos(y0)))), #s(#pos(#neg(#pos(y1))))))
   #LESS(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))) -> c15(#COMPARE(#s(#pos(#neg(#s(y0)))), #s(#pos(#neg(#s(y1))))))
Defined Rule Symbols:   #less_2, merge_2, merge#1_2, merge#2_3, merge#3_5, mergesort_1, mergesort#1_1, mergesort#2_2, mergesort#3_1, msplit_1, msplit#1_1, msplit#2_2, msplit#3_3, #cklt_1, #compare_2

Defined Pair Symbols:   MERGE#2_3, MERGESORT#2_2, MERGESORT#3_1, #COMPARE_2, MERGE#3_5, MERGE_2, MERGE#1_2, MERGESORT_1, MERGESORT#1_1, MSPLIT_1, MSPLIT#1_1, #LESS_2, MSPLIT#2_2

Compound Symbols:   c19_2, c26_1, c28_2, c29_2, c12_1, c21_1, c22_1, c14_1, c16_1, c29_1, c17_1, c23_1, c24_1, c30_1, c31_1, c15_1, c19_1, c33_1, c26_2, c8_1