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


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

(0) CpxTRS
(1) RenamingProof [BOTH BOUNDS(ID, ID), 0 ms]
(2) CpxTRS
(3) RelTrsToTrsProof [UPPER BOUND(ID), 0 ms]
(4) CpxTRS
(5) RelTrsToWeightedTrsProof [UPPER BOUND(ID), 0 ms]
(6) CpxWeightedTrs
    (7) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
    (8) CpxTypedWeightedTrs
    (9) CompletionProof [UPPER BOUND(ID), 0 ms]
    (10) CpxTypedWeightedCompleteTrs
        (11) NarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (12) CpxTypedWeightedCompleteTrs
        (13) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
        (14) CpxRNTS
        (15) SimplificationProof [BOTH BOUNDS(ID, ID), 30 ms]
        (16) CpxRNTS
        (17) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 0 ms]
        (18) CpxRNTS
        (19) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (20) CpxRNTS
        (21) IntTrsBoundProof [UPPER BOUND(ID), 231 ms]
        (22) CpxRNTS
        (23) IntTrsBoundProof [UPPER BOUND(ID), 140 ms]
        (24) CpxRNTS
        (25) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (26) CpxRNTS
        (27) IntTrsBoundProof [UPPER BOUND(ID), 317 ms]
        (28) CpxRNTS
        (29) IntTrsBoundProof [UPPER BOUND(ID), 188 ms]
        (30) CpxRNTS
        (31) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (32) CpxRNTS
        (33) IntTrsBoundProof [UPPER BOUND(ID), 120 ms]
        (34) CpxRNTS
        (35) IntTrsBoundProof [UPPER BOUND(ID), 43 ms]
        (36) CpxRNTS
        (37) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (38) CpxRNTS
        (39) IntTrsBoundProof [UPPER BOUND(ID), 149 ms]
        (40) CpxRNTS
        (41) IntTrsBoundProof [UPPER BOUND(ID), 5 ms]
        (42) CpxRNTS
        (43) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (44) CpxRNTS
        (45) IntTrsBoundProof [UPPER BOUND(ID), 99 ms]
        (46) CpxRNTS
        (47) IntTrsBoundProof [UPPER BOUND(ID), 22 ms]
        (48) CpxRNTS
        (49) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (50) CpxRNTS
        (51) IntTrsBoundProof [UPPER BOUND(ID), 343 ms]
        (52) CpxRNTS
        (53) IntTrsBoundProof [UPPER BOUND(ID), 84 ms]
        (54) CpxRNTS
        (55) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (56) CpxRNTS
        (57) IntTrsBoundProof [UPPER BOUND(ID), 556 ms]
        (58) CpxRNTS
        (59) IntTrsBoundProof [UPPER BOUND(ID), 339 ms]
        (60) CpxRNTS
        (61) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (62) CpxRNTS
        (63) IntTrsBoundProof [UPPER BOUND(ID), 1713 ms]
        (64) CpxRNTS
        (65) IntTrsBoundProof [UPPER BOUND(ID), 610 ms]
        (66) CpxRNTS
        (67) ResultPropagationProof [UPPER BOUND(ID), 1 ms]
        (68) CpxRNTS
        (69) IntTrsBoundProof [UPPER BOUND(ID), 18.9 s]
        (70) CpxRNTS
        (71) IntTrsBoundProof [UPPER BOUND(ID), 6575 ms]
        (72) CpxRNTS
    (73) CompletionProof [UPPER BOUND(ID), 0 ms]
    (74) CpxTypedWeightedCompleteTrs
        (75) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 7 ms]
        (76) CpxRNTS
(77) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms]
(78) CdtProblem
    (79) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms]
    (80) CdtProblem
    (81) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (82) CdtProblem
    (83) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 7 ms]
    (84) CdtProblem
    (85) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (86) CdtProblem
    (87) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (88) CdtProblem
    (89) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (90) CdtProblem
    (91) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (92) CdtProblem
    (93) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (94) CdtProblem
    (95) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (96) CdtProblem
    (97) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (98) CdtProblem
    (99) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (100) CdtProblem
    (101) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 3 ms]
    (102) CdtProblem
    (103) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (104) CdtProblem
    (105) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (106) CdtProblem
    (107) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (108) CdtProblem
    (109) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (110) CdtProblem
    (111) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
    (112) CdtProblem
    (113) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 164 ms]
    (114) CdtProblem
    (115) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (116) CdtProblem
    (117) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (118) CdtProblem
    (119) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (120) CdtProblem
    (121) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
    (122) CdtProblem
    (123) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 185 ms]
    (124) CdtProblem
    (125) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 2 ms]
    (126) CdtProblem
    (127) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (128) CdtProblem
    (129) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (130) CdtProblem
    (131) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
    (132) CdtProblem
    (133) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 181 ms]
    (134) CdtProblem
    (135) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (136) CdtProblem
    (137) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (138) CdtProblem
    (139) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (140) CdtProblem
    (141) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (142) CdtProblem
    (143) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (144) CdtProblem
    (145) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (146) CdtProblem
    (147) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (148) CdtProblem
    (149) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 200 ms]
    (150) CdtProblem
    (151) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (152) CdtProblem
    (153) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (154) CdtProblem
    (155) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 185 ms]
    (156) CdtProblem
    (157) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (158) CdtProblem
    (159) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 236 ms]
    (160) CdtProblem
    (161) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 5 ms]
    (162) CdtProblem
    (163) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 240 ms]
    (164) CdtProblem
    (165) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 1 ms]
    (166) CdtProblem
    (167) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 264 ms]
    (168) CdtProblem
    (169) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (170) CdtProblem
    (171) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 233 ms]
    (172) CdtProblem
    (173) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (174) CdtProblem
    (175) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (176) CdtProblem
    (177) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (178) CdtProblem
    (179) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (180) CdtProblem
    (181) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (182) CdtProblem
    (183) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (184) CdtProblem
    (185) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
    (186) CdtProblem
    (187) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (188) CdtProblem
    (189) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 260 ms]
    (190) CdtProblem
    (191) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (192) CdtProblem
    (193) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 365 ms]
    (194) CdtProblem
    (195) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (196) CdtProblem
    (197) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 351 ms]
    (198) CdtProblem
    (199) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (200) CdtProblem
    (201) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (202) CdtProblem
    (203) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (204) CdtProblem
    (205) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (206) CdtProblem
    (207) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (208) CdtProblem
    (209) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (210) CdtProblem
    (211) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (212) CdtProblem
    (213) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (214) CdtProblem
    (215) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
    (216) CdtProblem
    (217) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (218) CdtProblem
    (219) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 445 ms]
    (220) CdtProblem
    (221) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (222) CdtProblem
    (223) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 359 ms]
    (224) CdtProblem
    (225) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (226) CdtProblem
    (227) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 401 ms]
    (228) CdtProblem
    (229) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (230) CdtProblem
    (231) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (232) CdtProblem
    (233) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (234) CdtProblem
    (235) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (236) CdtProblem
    (237) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
    (238) CdtProblem
    (239) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 409 ms]
    (240) CdtProblem
    (241) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 1 ms]
    (242) CdtProblem
    (243) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (244) CdtProblem
    (245) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 487 ms]
    (246) CdtProblem
    (247) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (248) CdtProblem
    (249) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (250) CdtProblem
    (251) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 373 ms]
    (252) CdtProblem
    (253) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (254) CdtProblem
    (255) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (256) CdtProblem
    (257) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 427 ms]
    (258) CdtProblem
    (259) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (260) CdtProblem
    (261) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (262) CdtProblem
    (263) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (264) CdtProblem
    (265) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (266) CdtProblem
    (267) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (268) CdtProblem
    (269) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 453 ms]
    (270) CdtProblem
    (271) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (272) CdtProblem


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

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


The TRS R consists of the following rules:

   eq(0, 0) -> true
   eq(0, s(x)) -> false
   eq(s(x), 0) -> false
   eq(s(x), s(y)) -> eq(x, y)
   le(0, y) -> true
   le(s(x), 0) -> false
   le(s(x), s(y)) -> le(x, y)
   app(nil, y) -> y
   app(add(n, x), y) -> add(n, app(x, y))
   min(add(n, nil)) -> n
   min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
   if_min(true, add(n, add(m, x))) -> min(add(n, x))
   if_min(false, add(n, add(m, x))) -> min(add(m, x))
   head(add(n, x)) -> n
   tail(add(n, x)) -> x
   tail(nil) -> nil
   null(nil) -> true
   null(add(n, x)) -> false
   rm(n, nil) -> nil
   rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
   if_rm(true, n, add(m, x)) -> rm(n, x)
   if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
   minsort(x) -> mins(x, nil, nil)
   mins(x, y, z) -> if(null(x), x, y, z)
   if(true, x, y, z) -> z
   if(false, x, y, z) -> if2(eq(head(x), min(x)), x, y, z)
   if2(true, x, y, z) -> mins(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil)))
   if2(false, x, y, z) -> mins(tail(x), add(head(x), y), z)

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

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

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


The TRS R consists of the following rules:

   eq(0', 0') -> true
   eq(0', s(x)) -> false
   eq(s(x), 0') -> false
   eq(s(x), s(y)) -> eq(x, y)
   le(0', y) -> true
   le(s(x), 0') -> false
   le(s(x), s(y)) -> le(x, y)
   app(nil, y) -> y
   app(add(n, x), y) -> add(n, app(x, y))
   min(add(n, nil)) -> n
   min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
   if_min(true, add(n, add(m, x))) -> min(add(n, x))
   if_min(false, add(n, add(m, x))) -> min(add(m, x))
   head(add(n, x)) -> n
   tail(add(n, x)) -> x
   tail(nil) -> nil
   null(nil) -> true
   null(add(n, x)) -> false
   rm(n, nil) -> nil
   rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
   if_rm(true, n, add(m, x)) -> rm(n, x)
   if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
   minsort(x) -> mins(x, nil, nil)
   mins(x, y, z) -> if(null(x), x, y, z)
   if(true, x, y, z) -> z
   if(false, x, y, z) -> if2(eq(head(x), min(x)), x, y, z)
   if2(true, x, y, z) -> mins(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil)))
   if2(false, x, y, z) -> mins(tail(x), add(head(x), y), z)

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

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

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


The TRS R consists of the following rules:

   eq(0, 0) -> true
   eq(0, s(x)) -> false
   eq(s(x), 0) -> false
   eq(s(x), s(y)) -> eq(x, y)
   le(0, y) -> true
   le(s(x), 0) -> false
   le(s(x), s(y)) -> le(x, y)
   app(nil, y) -> y
   app(add(n, x), y) -> add(n, app(x, y))
   min(add(n, nil)) -> n
   min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x)))
   if_min(true, add(n, add(m, x))) -> min(add(n, x))
   if_min(false, add(n, add(m, x))) -> min(add(m, x))
   head(add(n, x)) -> n
   tail(add(n, x)) -> x
   tail(nil) -> nil
   null(nil) -> true
   null(add(n, x)) -> false
   rm(n, nil) -> nil
   rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x))
   if_rm(true, n, add(m, x)) -> rm(n, x)
   if_rm(false, n, add(m, x)) -> add(m, rm(n, x))
   minsort(x) -> mins(x, nil, nil)
   mins(x, y, z) -> if(null(x), x, y, z)
   if(true, x, y, z) -> z
   if(false, x, y, z) -> if2(eq(head(x), min(x)), x, y, z)
   if2(true, x, y, z) -> mins(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil)))
   if2(false, x, y, z) -> mins(tail(x), add(head(x), y), z)

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

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

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


The TRS R consists of the following rules:

   eq(0, 0) -> true [1]
   eq(0, s(x)) -> false [1]
   eq(s(x), 0) -> false [1]
   eq(s(x), s(y)) -> eq(x, y) [1]
   le(0, y) -> true [1]
   le(s(x), 0) -> false [1]
   le(s(x), s(y)) -> le(x, y) [1]
   app(nil, y) -> y [1]
   app(add(n, x), y) -> add(n, app(x, y)) [1]
   min(add(n, nil)) -> n [1]
   min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x))) [1]
   if_min(true, add(n, add(m, x))) -> min(add(n, x)) [1]
   if_min(false, add(n, add(m, x))) -> min(add(m, x)) [1]
   head(add(n, x)) -> n [1]
   tail(add(n, x)) -> x [1]
   tail(nil) -> nil [1]
   null(nil) -> true [1]
   null(add(n, x)) -> false [1]
   rm(n, nil) -> nil [1]
   rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x)) [1]
   if_rm(true, n, add(m, x)) -> rm(n, x) [1]
   if_rm(false, n, add(m, x)) -> add(m, rm(n, x)) [1]
   minsort(x) -> mins(x, nil, nil) [1]
   mins(x, y, z) -> if(null(x), x, y, z) [1]
   if(true, x, y, z) -> z [1]
   if(false, x, y, z) -> if2(eq(head(x), min(x)), x, y, z) [1]
   if2(true, x, y, z) -> mins(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil))) [1]
   if2(false, x, y, z) -> mins(tail(x), add(head(x), y), z) [1]

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

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

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

   eq(0, 0) -> true [1]
   eq(0, s(x)) -> false [1]
   eq(s(x), 0) -> false [1]
   eq(s(x), s(y)) -> eq(x, y) [1]
   le(0, y) -> true [1]
   le(s(x), 0) -> false [1]
   le(s(x), s(y)) -> le(x, y) [1]
   app(nil, y) -> y [1]
   app(add(n, x), y) -> add(n, app(x, y)) [1]
   min(add(n, nil)) -> n [1]
   min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x))) [1]
   if_min(true, add(n, add(m, x))) -> min(add(n, x)) [1]
   if_min(false, add(n, add(m, x))) -> min(add(m, x)) [1]
   head(add(n, x)) -> n [1]
   tail(add(n, x)) -> x [1]
   tail(nil) -> nil [1]
   null(nil) -> true [1]
   null(add(n, x)) -> false [1]
   rm(n, nil) -> nil [1]
   rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x)) [1]
   if_rm(true, n, add(m, x)) -> rm(n, x) [1]
   if_rm(false, n, add(m, x)) -> add(m, rm(n, x)) [1]
   minsort(x) -> mins(x, nil, nil) [1]
   mins(x, y, z) -> if(null(x), x, y, z) [1]
   if(true, x, y, z) -> z [1]
   if(false, x, y, z) -> if2(eq(head(x), min(x)), x, y, z) [1]
   if2(true, x, y, z) -> mins(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil))) [1]
   if2(false, x, y, z) -> mins(tail(x), add(head(x), y), z) [1]

The TRS has the following type information:
eq :: 0:s -> 0:s -> true:false
0 :: 0:s
true :: true:false
s :: 0:s -> 0:s
false :: true:false
le :: 0:s -> 0:s -> true:false
app :: nil:add -> nil:add -> nil:add
nil :: nil:add
add :: 0:s -> nil:add -> nil:add
min :: nil:add -> 0:s
if_min :: true:false -> nil:add -> 0:s
head :: nil:add -> 0:s
tail :: nil:add -> nil:add
null :: nil:add -> true:false
rm :: 0:s -> nil:add -> nil:add
if_rm :: true:false -> 0:s -> nil:add -> nil:add
minsort :: nil:add -> nil:add
mins :: nil:add -> nil:add -> nil:add -> nil:add
if :: true:false -> nil:add -> nil:add -> nil:add -> nil:add
if2 :: true:false -> nil:add -> nil:add -> nil:add -> nil:add

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

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

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

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

   minsort_1
   mins_3
   if_4
   if2_4

(c) The following functions are completely defined:

   eq_2
   head_1
   min_1
   le_2
   app_2
   rm_2
   tail_1
   null_1
   if_min_2
   if_rm_3

Due to the following rules being added:

   head(v0) -> 0 [0]
   min(v0) -> 0 [0]
   if_min(v0, v1) -> 0 [0]
   if_rm(v0, v1, v2) -> nil [0]

And the following fresh constants: none

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

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

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

   eq(0, 0) -> true [1]
   eq(0, s(x)) -> false [1]
   eq(s(x), 0) -> false [1]
   eq(s(x), s(y)) -> eq(x, y) [1]
   le(0, y) -> true [1]
   le(s(x), 0) -> false [1]
   le(s(x), s(y)) -> le(x, y) [1]
   app(nil, y) -> y [1]
   app(add(n, x), y) -> add(n, app(x, y)) [1]
   min(add(n, nil)) -> n [1]
   min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x))) [1]
   if_min(true, add(n, add(m, x))) -> min(add(n, x)) [1]
   if_min(false, add(n, add(m, x))) -> min(add(m, x)) [1]
   head(add(n, x)) -> n [1]
   tail(add(n, x)) -> x [1]
   tail(nil) -> nil [1]
   null(nil) -> true [1]
   null(add(n, x)) -> false [1]
   rm(n, nil) -> nil [1]
   rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x)) [1]
   if_rm(true, n, add(m, x)) -> rm(n, x) [1]
   if_rm(false, n, add(m, x)) -> add(m, rm(n, x)) [1]
   minsort(x) -> mins(x, nil, nil) [1]
   mins(x, y, z) -> if(null(x), x, y, z) [1]
   if(true, x, y, z) -> z [1]
   if(false, x, y, z) -> if2(eq(head(x), min(x)), x, y, z) [1]
   if2(true, x, y, z) -> mins(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil))) [1]
   if2(false, x, y, z) -> mins(tail(x), add(head(x), y), z) [1]
   head(v0) -> 0 [0]
   min(v0) -> 0 [0]
   if_min(v0, v1) -> 0 [0]
   if_rm(v0, v1, v2) -> nil [0]

The TRS has the following type information:
eq :: 0:s -> 0:s -> true:false
0 :: 0:s
true :: true:false
s :: 0:s -> 0:s
false :: true:false
le :: 0:s -> 0:s -> true:false
app :: nil:add -> nil:add -> nil:add
nil :: nil:add
add :: 0:s -> nil:add -> nil:add
min :: nil:add -> 0:s
if_min :: true:false -> nil:add -> 0:s
head :: nil:add -> 0:s
tail :: nil:add -> nil:add
null :: nil:add -> true:false
rm :: 0:s -> nil:add -> nil:add
if_rm :: true:false -> 0:s -> nil:add -> nil:add
minsort :: nil:add -> nil:add
mins :: nil:add -> nil:add -> nil:add -> nil:add
if :: true:false -> nil:add -> nil:add -> nil:add -> nil:add
if2 :: true:false -> nil:add -> nil:add -> nil:add -> nil:add

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

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

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

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

   eq(0, 0) -> true [1]
   eq(0, s(x)) -> false [1]
   eq(s(x), 0) -> false [1]
   eq(s(x), s(y)) -> eq(x, y) [1]
   le(0, y) -> true [1]
   le(s(x), 0) -> false [1]
   le(s(x), s(y)) -> le(x, y) [1]
   app(nil, y) -> y [1]
   app(add(n, x), y) -> add(n, app(x, y)) [1]
   min(add(n, nil)) -> n [1]
   min(add(0, add(m, x))) -> if_min(true, add(0, add(m, x))) [2]
   min(add(s(x'), add(0, x))) -> if_min(false, add(s(x'), add(0, x))) [2]
   min(add(s(x''), add(s(y'), x))) -> if_min(le(x'', y'), add(s(x''), add(s(y'), x))) [2]
   if_min(true, add(n, add(m, x))) -> min(add(n, x)) [1]
   if_min(false, add(n, add(m, x))) -> min(add(m, x)) [1]
   head(add(n, x)) -> n [1]
   tail(add(n, x)) -> x [1]
   tail(nil) -> nil [1]
   null(nil) -> true [1]
   null(add(n, x)) -> false [1]
   rm(n, nil) -> nil [1]
   rm(0, add(0, x)) -> if_rm(true, 0, add(0, x)) [2]
   rm(0, add(s(x1), x)) -> if_rm(false, 0, add(s(x1), x)) [2]
   rm(s(x2), add(0, x)) -> if_rm(false, s(x2), add(0, x)) [2]
   rm(s(x3), add(s(y''), x)) -> if_rm(eq(x3, y''), s(x3), add(s(y''), x)) [2]
   if_rm(true, n, add(m, x)) -> rm(n, x) [1]
   if_rm(false, n, add(m, x)) -> add(m, rm(n, x)) [1]
   minsort(x) -> mins(x, nil, nil) [1]
   mins(nil, y, z) -> if(true, nil, y, z) [2]
   mins(add(n', x4), y, z) -> if(false, add(n', x4), y, z) [2]
   if(true, x, y, z) -> z [1]
   if(false, add(n'', nil), y, z) -> if2(eq(n'', n''), add(n'', nil), y, z) [3]
   if(false, add(n'', add(m', x6)), y, z) -> if2(eq(n'', if_min(le(n'', m'), add(n'', add(m', x6)))), add(n'', add(m', x6)), y, z) [3]
   if(false, add(n'', x5), y, z) -> if2(eq(n'', 0), add(n'', x5), y, z) [2]
   if(false, add(n1, nil), y, z) -> if2(eq(0, n1), add(n1, nil), y, z) [2]
   if(false, add(n2, add(m'', x7)), y, z) -> if2(eq(0, if_min(le(n2, m''), add(n2, add(m'', x7)))), add(n2, add(m'', x7)), y, z) [2]
   if(false, x, y, z) -> if2(eq(0, 0), x, y, z) [1]
   if2(true, add(n3, x8), y, z) -> mins(app(rm(n3, x8), y), nil, app(z, add(n3, nil))) [4]
   if2(true, add(n3, x8), y, z) -> mins(app(rm(n3, x8), y), nil, app(z, add(0, nil))) [3]
   if2(true, add(n4, x9), y, z) -> mins(app(rm(0, x9), y), nil, app(z, add(n4, nil))) [3]
   if2(true, add(n4, x9), y, z) -> mins(app(rm(0, x9), y), nil, app(z, add(0, nil))) [2]
   if2(true, nil, y, z) -> mins(app(rm(0, nil), y), nil, app(z, add(0, nil))) [2]
   if2(false, add(n5, x10), y, z) -> mins(x10, add(n5, y), z) [3]
   if2(false, add(n5, x10), y, z) -> mins(x10, add(0, y), z) [2]
   if2(false, nil, y, z) -> mins(nil, add(0, y), z) [2]
   head(v0) -> 0 [0]
   min(v0) -> 0 [0]
   if_min(v0, v1) -> 0 [0]
   if_rm(v0, v1, v2) -> nil [0]

The TRS has the following type information:
eq :: 0:s -> 0:s -> true:false
0 :: 0:s
true :: true:false
s :: 0:s -> 0:s
false :: true:false
le :: 0:s -> 0:s -> true:false
app :: nil:add -> nil:add -> nil:add
nil :: nil:add
add :: 0:s -> nil:add -> nil:add
min :: nil:add -> 0:s
if_min :: true:false -> nil:add -> 0:s
head :: nil:add -> 0:s
tail :: nil:add -> nil:add
null :: nil:add -> true:false
rm :: 0:s -> nil:add -> nil:add
if_rm :: true:false -> 0:s -> nil:add -> nil:add
minsort :: nil:add -> nil:add
mins :: nil:add -> nil:add -> nil:add -> nil:add
if :: true:false -> nil:add -> nil:add -> nil:add -> nil:add
if2 :: true:false -> nil:add -> nil:add -> nil:add -> nil:add

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

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

   0 => 0
   true => 1
   false => 0
   nil => 0

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

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

   app(z', z'') -{ 1 }-> y :|: z'' = y, y >= 0, z' = 0
   app(z', z'') -{ 1 }-> 1 + n + app(x, y) :|: n >= 0, z'' = y, z' = 1 + n + x, x >= 0, y >= 0
   eq(z', z'') -{ 1 }-> eq(x, y) :|: z' = 1 + x, x >= 0, y >= 0, z'' = 1 + y
   eq(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: x >= 0, z'' = 1 + x, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' = 1 + x, x >= 0
   head(z') -{ 1 }-> n :|: n >= 0, z' = 1 + n + x, x >= 0
   head(z') -{ 0 }-> 0 :|: v0 >= 0, z' = v0
   if(z', z'', z1, z2) -{ 1 }-> z :|: z1 = y, z >= 0, z2 = z, x >= 0, y >= 0, z'' = x, z' = 1
   if(z', z'', z1, z2) -{ 3 }-> if2(eq(n'', n''), 1 + n'' + 0, y, z) :|: z1 = y, z >= 0, z2 = z, y >= 0, n'' >= 0, z'' = 1 + n'' + 0, z' = 0
   if(z', z'', z1, z2) -{ 3 }-> if2(eq(n'', if_min(le(n'', m'), 1 + n'' + (1 + m' + x6))), 1 + n'' + (1 + m' + x6), y, z) :|: z1 = y, z >= 0, z2 = z, y >= 0, m' >= 0, x6 >= 0, n'' >= 0, z'' = 1 + n'' + (1 + m' + x6), z' = 0
   if(z', z'', z1, z2) -{ 2 }-> if2(eq(n'', 0), 1 + n'' + x5, y, z) :|: z'' = 1 + n'' + x5, z1 = y, x5 >= 0, z >= 0, z2 = z, y >= 0, n'' >= 0, z' = 0
   if(z', z'', z1, z2) -{ 2 }-> if2(eq(0, n1), 1 + n1 + 0, y, z) :|: z1 = y, z >= 0, z'' = 1 + n1 + 0, z2 = z, y >= 0, n1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 2 }-> if2(eq(0, if_min(le(n2, m''), 1 + n2 + (1 + m'' + x7))), 1 + n2 + (1 + m'' + x7), y, z) :|: z1 = y, z >= 0, m'' >= 0, x7 >= 0, z2 = z, y >= 0, z'' = 1 + n2 + (1 + m'' + x7), n2 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 1 }-> if2(eq(0, 0), x, y, z) :|: z1 = y, z >= 0, z2 = z, x >= 0, y >= 0, z'' = x, z' = 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(x10, 1 + n5 + y, z) :|: z1 = y, z >= 0, z2 = z, y >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(x10, 1 + 0 + y, z) :|: z1 = y, z >= 0, z2 = z, y >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 4 }-> mins(app(rm(n3, x8), y), 0, app(z, 1 + n3 + 0)) :|: z1 = y, z >= 0, x8 >= 0, z2 = z, y >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(n3, x8), y), 0, app(z, 1 + 0 + 0)) :|: z1 = y, z >= 0, x8 >= 0, z2 = z, y >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(0, x9), y), 0, app(z, 1 + n4 + 0)) :|: z1 = y, n4 >= 0, z >= 0, z2 = z, y >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, x9), y), 0, app(z, 1 + 0 + 0)) :|: z1 = y, n4 >= 0, z >= 0, z2 = z, y >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, 0), y), 0, app(z, 1 + 0 + 0)) :|: z'' = 0, z1 = y, z >= 0, z2 = z, y >= 0, z' = 1
   if2(z', z'', z1, z2) -{ 2 }-> mins(0, 1 + 0 + y, z) :|: z'' = 0, z1 = y, z >= 0, z2 = z, y >= 0, z' = 0
   if_min(z', z'') -{ 1 }-> min(1 + m + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 0, m >= 0
   if_min(z', z'') -{ 1 }-> min(1 + n + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 1, m >= 0
   if_min(z', z'') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z'' = v1, z' = v0
   if_rm(z', z'', z1) -{ 1 }-> rm(n, x) :|: n >= 0, z'' = n, x >= 0, z1 = 1 + m + x, z' = 1, m >= 0
   if_rm(z', z'', z1) -{ 0 }-> 0 :|: v0 >= 0, z1 = v2, v1 >= 0, z'' = v1, v2 >= 0, z' = v0
   if_rm(z', z'', z1) -{ 1 }-> 1 + m + rm(n, x) :|: n >= 0, z'' = n, x >= 0, z1 = 1 + m + x, z' = 0, m >= 0
   le(z', z'') -{ 1 }-> le(x, y) :|: z' = 1 + x, x >= 0, y >= 0, z'' = 1 + y
   le(z', z'') -{ 1 }-> 1 :|: z'' = y, y >= 0, z' = 0
   le(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' = 1 + x, x >= 0
   min(z') -{ 1 }-> n :|: n >= 0, z' = 1 + n + 0
   min(z') -{ 2 }-> if_min(le(x'', y'), 1 + (1 + x'') + (1 + (1 + y') + x)) :|: x >= 0, y' >= 0, z' = 1 + (1 + x'') + (1 + (1 + y') + x), x'' >= 0
   min(z') -{ 2 }-> if_min(1, 1 + 0 + (1 + m + x)) :|: x >= 0, z' = 1 + 0 + (1 + m + x), m >= 0
   min(z') -{ 2 }-> if_min(0, 1 + (1 + x') + (1 + 0 + x)) :|: x' >= 0, x >= 0, z' = 1 + (1 + x') + (1 + 0 + x)
   min(z') -{ 0 }-> 0 :|: v0 >= 0, z' = v0
   mins(z', z'', z1) -{ 2 }-> if(1, 0, y, z) :|: z1 = z, z >= 0, z'' = y, y >= 0, z' = 0
   mins(z', z'', z1) -{ 2 }-> if(0, 1 + n' + x4, y, z) :|: z1 = z, x4 >= 0, z >= 0, z' = 1 + n' + x4, z'' = y, y >= 0, n' >= 0
   minsort(z') -{ 1 }-> mins(x, 0, 0) :|: z' = x, x >= 0
   null(z') -{ 1 }-> 1 :|: z' = 0
   null(z') -{ 1 }-> 0 :|: n >= 0, z' = 1 + n + x, x >= 0
   rm(z', z'') -{ 2 }-> if_rm(eq(x3, y''), 1 + x3, 1 + (1 + y'') + x) :|: z'' = 1 + (1 + y'') + x, z' = 1 + x3, x >= 0, y'' >= 0, x3 >= 0
   rm(z', z'') -{ 2 }-> if_rm(1, 0, 1 + 0 + x) :|: x >= 0, z'' = 1 + 0 + x, z' = 0
   rm(z', z'') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 0, z'' = 1 + (1 + x1) + x
   rm(z', z'') -{ 2 }-> if_rm(0, 1 + x2, 1 + 0 + x) :|: z' = 1 + x2, x >= 0, z'' = 1 + 0 + x, x2 >= 0
   rm(z', z'') -{ 1 }-> 0 :|: z'' = 0, n >= 0, z' = n
   tail(z') -{ 1 }-> x :|: n >= 0, z' = 1 + n + x, x >= 0
   tail(z') -{ 1 }-> 0 :|: z' = 0


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

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

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

   app(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0
   app(z', z'') -{ 1 }-> 1 + n + app(x, z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0
   eq(z', z'') -{ 1 }-> eq(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0
   eq(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' - 1 >= 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   head(z') -{ 1 }-> n :|: n >= 0, z' = 1 + n + x, x >= 0
   head(z') -{ 0 }-> 0 :|: z' >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 3 }-> if2(eq(n'', if_min(le(n'', m'), 1 + n'' + (1 + m' + x6))), 1 + n'' + (1 + m' + x6), z1, z2) :|: z2 >= 0, z1 >= 0, m' >= 0, x6 >= 0, n'' >= 0, z'' = 1 + n'' + (1 + m' + x6), z' = 0
   if(z', z'', z1, z2) -{ 2 }-> if2(eq(n'', 0), 1 + n'' + x5, z1, z2) :|: z'' = 1 + n'' + x5, x5 >= 0, z2 >= 0, z1 >= 0, n'' >= 0, z' = 0
   if(z', z'', z1, z2) -{ 2 }-> if2(eq(0, if_min(le(n2, m''), 1 + n2 + (1 + m'' + x7))), 1 + n2 + (1 + m'' + x7), z1, z2) :|: z2 >= 0, m'' >= 0, x7 >= 0, z1 >= 0, z'' = 1 + n2 + (1 + m'' + x7), n2 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 1 }-> if2(eq(0, 0), z'', z1, z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 2 }-> if2(eq(0, z'' - 1), 1 + (z'' - 1) + 0, z1, z2) :|: z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 3 }-> if2(eq(z'' - 1, z'' - 1), 1 + (z'' - 1) + 0, z1, z2) :|: z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(x10, 1 + n5 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(x10, 1 + 0 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 4 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + n3 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + 0 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + n4 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + 0 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, 0), z1), 0, app(z2, 1 + 0 + 0)) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 1
   if2(z', z'', z1, z2) -{ 2 }-> mins(0, 1 + 0 + z1, z2) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 0
   if_min(z', z'') -{ 1 }-> min(1 + m + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 0, m >= 0
   if_min(z', z'') -{ 1 }-> min(1 + n + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 1, m >= 0
   if_min(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   if_rm(z', z'', z1) -{ 1 }-> rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 1, m >= 0
   if_rm(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   if_rm(z', z'', z1) -{ 1 }-> 1 + m + rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 0, m >= 0
   le(z', z'') -{ 1 }-> le(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 1 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   min(z') -{ 2 }-> if_min(le(x'', y'), 1 + (1 + x'') + (1 + (1 + y') + x)) :|: x >= 0, y' >= 0, z' = 1 + (1 + x'') + (1 + (1 + y') + x), x'' >= 0
   min(z') -{ 2 }-> if_min(1, 1 + 0 + (1 + m + x)) :|: x >= 0, z' = 1 + 0 + (1 + m + x), m >= 0
   min(z') -{ 2 }-> if_min(0, 1 + (1 + x') + (1 + 0 + x)) :|: x' >= 0, x >= 0, z' = 1 + (1 + x') + (1 + 0 + x)
   min(z') -{ 0 }-> 0 :|: z' >= 0
   min(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   mins(z', z'', z1) -{ 2 }-> if(1, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0
   mins(z', z'', z1) -{ 2 }-> if(0, 1 + n' + x4, z'', z1) :|: x4 >= 0, z1 >= 0, z' = 1 + n' + x4, z'' >= 0, n' >= 0
   minsort(z') -{ 1 }-> mins(z', 0, 0) :|: z' >= 0
   null(z') -{ 1 }-> 1 :|: z' = 0
   null(z') -{ 1 }-> 0 :|: n >= 0, z' = 1 + n + x, x >= 0
   rm(z', z'') -{ 2 }-> if_rm(eq(z' - 1, y''), 1 + (z' - 1), 1 + (1 + y'') + x) :|: z'' = 1 + (1 + y'') + x, x >= 0, y'' >= 0, z' - 1 >= 0
   rm(z', z'') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' = 0
   rm(z', z'') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 0, z'' = 1 + (1 + x1) + x
   rm(z', z'') -{ 2 }-> if_rm(0, 1 + (z' - 1), 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' - 1 >= 0
   rm(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' >= 0
   tail(z') -{ 1 }-> x :|: n >= 0, z' = 1 + n + x, x >= 0
   tail(z') -{ 1 }-> 0 :|: z' = 0


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

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

   { le }
   { eq }
   { tail }
   { head }
   { null }
   { app }
   { min, if_min }
   { if_rm, rm }
   { if2, mins, if }
   { minsort }

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

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

   app(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0
   app(z', z'') -{ 1 }-> 1 + n + app(x, z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0
   eq(z', z'') -{ 1 }-> eq(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0
   eq(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' - 1 >= 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   head(z') -{ 1 }-> n :|: n >= 0, z' = 1 + n + x, x >= 0
   head(z') -{ 0 }-> 0 :|: z' >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 3 }-> if2(eq(n'', if_min(le(n'', m'), 1 + n'' + (1 + m' + x6))), 1 + n'' + (1 + m' + x6), z1, z2) :|: z2 >= 0, z1 >= 0, m' >= 0, x6 >= 0, n'' >= 0, z'' = 1 + n'' + (1 + m' + x6), z' = 0
   if(z', z'', z1, z2) -{ 2 }-> if2(eq(n'', 0), 1 + n'' + x5, z1, z2) :|: z'' = 1 + n'' + x5, x5 >= 0, z2 >= 0, z1 >= 0, n'' >= 0, z' = 0
   if(z', z'', z1, z2) -{ 2 }-> if2(eq(0, if_min(le(n2, m''), 1 + n2 + (1 + m'' + x7))), 1 + n2 + (1 + m'' + x7), z1, z2) :|: z2 >= 0, m'' >= 0, x7 >= 0, z1 >= 0, z'' = 1 + n2 + (1 + m'' + x7), n2 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 1 }-> if2(eq(0, 0), z'', z1, z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 2 }-> if2(eq(0, z'' - 1), 1 + (z'' - 1) + 0, z1, z2) :|: z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 3 }-> if2(eq(z'' - 1, z'' - 1), 1 + (z'' - 1) + 0, z1, z2) :|: z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(x10, 1 + n5 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(x10, 1 + 0 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 4 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + n3 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + 0 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + n4 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + 0 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, 0), z1), 0, app(z2, 1 + 0 + 0)) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 1
   if2(z', z'', z1, z2) -{ 2 }-> mins(0, 1 + 0 + z1, z2) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 0
   if_min(z', z'') -{ 1 }-> min(1 + m + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 0, m >= 0
   if_min(z', z'') -{ 1 }-> min(1 + n + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 1, m >= 0
   if_min(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   if_rm(z', z'', z1) -{ 1 }-> rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 1, m >= 0
   if_rm(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   if_rm(z', z'', z1) -{ 1 }-> 1 + m + rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 0, m >= 0
   le(z', z'') -{ 1 }-> le(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 1 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   min(z') -{ 2 }-> if_min(le(x'', y'), 1 + (1 + x'') + (1 + (1 + y') + x)) :|: x >= 0, y' >= 0, z' = 1 + (1 + x'') + (1 + (1 + y') + x), x'' >= 0
   min(z') -{ 2 }-> if_min(1, 1 + 0 + (1 + m + x)) :|: x >= 0, z' = 1 + 0 + (1 + m + x), m >= 0
   min(z') -{ 2 }-> if_min(0, 1 + (1 + x') + (1 + 0 + x)) :|: x' >= 0, x >= 0, z' = 1 + (1 + x') + (1 + 0 + x)
   min(z') -{ 0 }-> 0 :|: z' >= 0
   min(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   mins(z', z'', z1) -{ 2 }-> if(1, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0
   mins(z', z'', z1) -{ 2 }-> if(0, 1 + n' + x4, z'', z1) :|: x4 >= 0, z1 >= 0, z' = 1 + n' + x4, z'' >= 0, n' >= 0
   minsort(z') -{ 1 }-> mins(z', 0, 0) :|: z' >= 0
   null(z') -{ 1 }-> 1 :|: z' = 0
   null(z') -{ 1 }-> 0 :|: n >= 0, z' = 1 + n + x, x >= 0
   rm(z', z'') -{ 2 }-> if_rm(eq(z' - 1, y''), 1 + (z' - 1), 1 + (1 + y'') + x) :|: z'' = 1 + (1 + y'') + x, x >= 0, y'' >= 0, z' - 1 >= 0
   rm(z', z'') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' = 0
   rm(z', z'') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 0, z'' = 1 + (1 + x1) + x
   rm(z', z'') -{ 2 }-> if_rm(0, 1 + (z' - 1), 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' - 1 >= 0
   rm(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' >= 0
   tail(z') -{ 1 }-> x :|: n >= 0, z' = 1 + n + x, x >= 0
   tail(z') -{ 1 }-> 0 :|: z' = 0

Function symbols to be analyzed: {le}, {eq}, {tail}, {head}, {null}, {app}, {min,if_min}, {if_rm,rm}, {if2,mins,if}, {minsort}

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

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

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

   app(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0
   app(z', z'') -{ 1 }-> 1 + n + app(x, z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0
   eq(z', z'') -{ 1 }-> eq(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0
   eq(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' - 1 >= 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   head(z') -{ 1 }-> n :|: n >= 0, z' = 1 + n + x, x >= 0
   head(z') -{ 0 }-> 0 :|: z' >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 3 }-> if2(eq(n'', if_min(le(n'', m'), 1 + n'' + (1 + m' + x6))), 1 + n'' + (1 + m' + x6), z1, z2) :|: z2 >= 0, z1 >= 0, m' >= 0, x6 >= 0, n'' >= 0, z'' = 1 + n'' + (1 + m' + x6), z' = 0
   if(z', z'', z1, z2) -{ 2 }-> if2(eq(n'', 0), 1 + n'' + x5, z1, z2) :|: z'' = 1 + n'' + x5, x5 >= 0, z2 >= 0, z1 >= 0, n'' >= 0, z' = 0
   if(z', z'', z1, z2) -{ 2 }-> if2(eq(0, if_min(le(n2, m''), 1 + n2 + (1 + m'' + x7))), 1 + n2 + (1 + m'' + x7), z1, z2) :|: z2 >= 0, m'' >= 0, x7 >= 0, z1 >= 0, z'' = 1 + n2 + (1 + m'' + x7), n2 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 1 }-> if2(eq(0, 0), z'', z1, z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 2 }-> if2(eq(0, z'' - 1), 1 + (z'' - 1) + 0, z1, z2) :|: z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 3 }-> if2(eq(z'' - 1, z'' - 1), 1 + (z'' - 1) + 0, z1, z2) :|: z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(x10, 1 + n5 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(x10, 1 + 0 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 4 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + n3 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + 0 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + n4 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + 0 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, 0), z1), 0, app(z2, 1 + 0 + 0)) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 1
   if2(z', z'', z1, z2) -{ 2 }-> mins(0, 1 + 0 + z1, z2) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 0
   if_min(z', z'') -{ 1 }-> min(1 + m + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 0, m >= 0
   if_min(z', z'') -{ 1 }-> min(1 + n + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 1, m >= 0
   if_min(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   if_rm(z', z'', z1) -{ 1 }-> rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 1, m >= 0
   if_rm(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   if_rm(z', z'', z1) -{ 1 }-> 1 + m + rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 0, m >= 0
   le(z', z'') -{ 1 }-> le(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 1 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   min(z') -{ 2 }-> if_min(le(x'', y'), 1 + (1 + x'') + (1 + (1 + y') + x)) :|: x >= 0, y' >= 0, z' = 1 + (1 + x'') + (1 + (1 + y') + x), x'' >= 0
   min(z') -{ 2 }-> if_min(1, 1 + 0 + (1 + m + x)) :|: x >= 0, z' = 1 + 0 + (1 + m + x), m >= 0
   min(z') -{ 2 }-> if_min(0, 1 + (1 + x') + (1 + 0 + x)) :|: x' >= 0, x >= 0, z' = 1 + (1 + x') + (1 + 0 + x)
   min(z') -{ 0 }-> 0 :|: z' >= 0
   min(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   mins(z', z'', z1) -{ 2 }-> if(1, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0
   mins(z', z'', z1) -{ 2 }-> if(0, 1 + n' + x4, z'', z1) :|: x4 >= 0, z1 >= 0, z' = 1 + n' + x4, z'' >= 0, n' >= 0
   minsort(z') -{ 1 }-> mins(z', 0, 0) :|: z' >= 0
   null(z') -{ 1 }-> 1 :|: z' = 0
   null(z') -{ 1 }-> 0 :|: n >= 0, z' = 1 + n + x, x >= 0
   rm(z', z'') -{ 2 }-> if_rm(eq(z' - 1, y''), 1 + (z' - 1), 1 + (1 + y'') + x) :|: z'' = 1 + (1 + y'') + x, x >= 0, y'' >= 0, z' - 1 >= 0
   rm(z', z'') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' = 0
   rm(z', z'') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 0, z'' = 1 + (1 + x1) + x
   rm(z', z'') -{ 2 }-> if_rm(0, 1 + (z' - 1), 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' - 1 >= 0
   rm(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' >= 0
   tail(z') -{ 1 }-> x :|: n >= 0, z' = 1 + n + x, x >= 0
   tail(z') -{ 1 }-> 0 :|: z' = 0

Function symbols to be analyzed: {le}, {eq}, {tail}, {head}, {null}, {app}, {min,if_min}, {if_rm,rm}, {if2,mins,if}, {minsort}

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

(21) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   app(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0
   app(z', z'') -{ 1 }-> 1 + n + app(x, z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0
   eq(z', z'') -{ 1 }-> eq(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0
   eq(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' - 1 >= 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   head(z') -{ 1 }-> n :|: n >= 0, z' = 1 + n + x, x >= 0
   head(z') -{ 0 }-> 0 :|: z' >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 3 }-> if2(eq(n'', if_min(le(n'', m'), 1 + n'' + (1 + m' + x6))), 1 + n'' + (1 + m' + x6), z1, z2) :|: z2 >= 0, z1 >= 0, m' >= 0, x6 >= 0, n'' >= 0, z'' = 1 + n'' + (1 + m' + x6), z' = 0
   if(z', z'', z1, z2) -{ 2 }-> if2(eq(n'', 0), 1 + n'' + x5, z1, z2) :|: z'' = 1 + n'' + x5, x5 >= 0, z2 >= 0, z1 >= 0, n'' >= 0, z' = 0
   if(z', z'', z1, z2) -{ 2 }-> if2(eq(0, if_min(le(n2, m''), 1 + n2 + (1 + m'' + x7))), 1 + n2 + (1 + m'' + x7), z1, z2) :|: z2 >= 0, m'' >= 0, x7 >= 0, z1 >= 0, z'' = 1 + n2 + (1 + m'' + x7), n2 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 1 }-> if2(eq(0, 0), z'', z1, z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 2 }-> if2(eq(0, z'' - 1), 1 + (z'' - 1) + 0, z1, z2) :|: z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 3 }-> if2(eq(z'' - 1, z'' - 1), 1 + (z'' - 1) + 0, z1, z2) :|: z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(x10, 1 + n5 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(x10, 1 + 0 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 4 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + n3 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + 0 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + n4 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + 0 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, 0), z1), 0, app(z2, 1 + 0 + 0)) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 1
   if2(z', z'', z1, z2) -{ 2 }-> mins(0, 1 + 0 + z1, z2) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 0
   if_min(z', z'') -{ 1 }-> min(1 + m + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 0, m >= 0
   if_min(z', z'') -{ 1 }-> min(1 + n + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 1, m >= 0
   if_min(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   if_rm(z', z'', z1) -{ 1 }-> rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 1, m >= 0
   if_rm(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   if_rm(z', z'', z1) -{ 1 }-> 1 + m + rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 0, m >= 0
   le(z', z'') -{ 1 }-> le(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 1 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   min(z') -{ 2 }-> if_min(le(x'', y'), 1 + (1 + x'') + (1 + (1 + y') + x)) :|: x >= 0, y' >= 0, z' = 1 + (1 + x'') + (1 + (1 + y') + x), x'' >= 0
   min(z') -{ 2 }-> if_min(1, 1 + 0 + (1 + m + x)) :|: x >= 0, z' = 1 + 0 + (1 + m + x), m >= 0
   min(z') -{ 2 }-> if_min(0, 1 + (1 + x') + (1 + 0 + x)) :|: x' >= 0, x >= 0, z' = 1 + (1 + x') + (1 + 0 + x)
   min(z') -{ 0 }-> 0 :|: z' >= 0
   min(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   mins(z', z'', z1) -{ 2 }-> if(1, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0
   mins(z', z'', z1) -{ 2 }-> if(0, 1 + n' + x4, z'', z1) :|: x4 >= 0, z1 >= 0, z' = 1 + n' + x4, z'' >= 0, n' >= 0
   minsort(z') -{ 1 }-> mins(z', 0, 0) :|: z' >= 0
   null(z') -{ 1 }-> 1 :|: z' = 0
   null(z') -{ 1 }-> 0 :|: n >= 0, z' = 1 + n + x, x >= 0
   rm(z', z'') -{ 2 }-> if_rm(eq(z' - 1, y''), 1 + (z' - 1), 1 + (1 + y'') + x) :|: z'' = 1 + (1 + y'') + x, x >= 0, y'' >= 0, z' - 1 >= 0
   rm(z', z'') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' = 0
   rm(z', z'') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 0, z'' = 1 + (1 + x1) + x
   rm(z', z'') -{ 2 }-> if_rm(0, 1 + (z' - 1), 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' - 1 >= 0
   rm(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' >= 0
   tail(z') -{ 1 }-> x :|: n >= 0, z' = 1 + n + x, x >= 0
   tail(z') -{ 1 }-> 0 :|: z' = 0

Function symbols to be analyzed: {le}, {eq}, {tail}, {head}, {null}, {app}, {min,if_min}, {if_rm,rm}, {if2,mins,if}, {minsort}
Previous analysis results are:
  le: runtime: ?, size: O(1) [1]

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

(23) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   app(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0
   app(z', z'') -{ 1 }-> 1 + n + app(x, z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0
   eq(z', z'') -{ 1 }-> eq(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0
   eq(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' - 1 >= 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   head(z') -{ 1 }-> n :|: n >= 0, z' = 1 + n + x, x >= 0
   head(z') -{ 0 }-> 0 :|: z' >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 3 }-> if2(eq(n'', if_min(le(n'', m'), 1 + n'' + (1 + m' + x6))), 1 + n'' + (1 + m' + x6), z1, z2) :|: z2 >= 0, z1 >= 0, m' >= 0, x6 >= 0, n'' >= 0, z'' = 1 + n'' + (1 + m' + x6), z' = 0
   if(z', z'', z1, z2) -{ 2 }-> if2(eq(n'', 0), 1 + n'' + x5, z1, z2) :|: z'' = 1 + n'' + x5, x5 >= 0, z2 >= 0, z1 >= 0, n'' >= 0, z' = 0
   if(z', z'', z1, z2) -{ 2 }-> if2(eq(0, if_min(le(n2, m''), 1 + n2 + (1 + m'' + x7))), 1 + n2 + (1 + m'' + x7), z1, z2) :|: z2 >= 0, m'' >= 0, x7 >= 0, z1 >= 0, z'' = 1 + n2 + (1 + m'' + x7), n2 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 1 }-> if2(eq(0, 0), z'', z1, z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 2 }-> if2(eq(0, z'' - 1), 1 + (z'' - 1) + 0, z1, z2) :|: z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 3 }-> if2(eq(z'' - 1, z'' - 1), 1 + (z'' - 1) + 0, z1, z2) :|: z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(x10, 1 + n5 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(x10, 1 + 0 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 4 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + n3 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + 0 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + n4 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + 0 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, 0), z1), 0, app(z2, 1 + 0 + 0)) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 1
   if2(z', z'', z1, z2) -{ 2 }-> mins(0, 1 + 0 + z1, z2) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 0
   if_min(z', z'') -{ 1 }-> min(1 + m + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 0, m >= 0
   if_min(z', z'') -{ 1 }-> min(1 + n + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 1, m >= 0
   if_min(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   if_rm(z', z'', z1) -{ 1 }-> rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 1, m >= 0
   if_rm(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   if_rm(z', z'', z1) -{ 1 }-> 1 + m + rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 0, m >= 0
   le(z', z'') -{ 1 }-> le(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 1 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   min(z') -{ 2 }-> if_min(le(x'', y'), 1 + (1 + x'') + (1 + (1 + y') + x)) :|: x >= 0, y' >= 0, z' = 1 + (1 + x'') + (1 + (1 + y') + x), x'' >= 0
   min(z') -{ 2 }-> if_min(1, 1 + 0 + (1 + m + x)) :|: x >= 0, z' = 1 + 0 + (1 + m + x), m >= 0
   min(z') -{ 2 }-> if_min(0, 1 + (1 + x') + (1 + 0 + x)) :|: x' >= 0, x >= 0, z' = 1 + (1 + x') + (1 + 0 + x)
   min(z') -{ 0 }-> 0 :|: z' >= 0
   min(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   mins(z', z'', z1) -{ 2 }-> if(1, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0
   mins(z', z'', z1) -{ 2 }-> if(0, 1 + n' + x4, z'', z1) :|: x4 >= 0, z1 >= 0, z' = 1 + n' + x4, z'' >= 0, n' >= 0
   minsort(z') -{ 1 }-> mins(z', 0, 0) :|: z' >= 0
   null(z') -{ 1 }-> 1 :|: z' = 0
   null(z') -{ 1 }-> 0 :|: n >= 0, z' = 1 + n + x, x >= 0
   rm(z', z'') -{ 2 }-> if_rm(eq(z' - 1, y''), 1 + (z' - 1), 1 + (1 + y'') + x) :|: z'' = 1 + (1 + y'') + x, x >= 0, y'' >= 0, z' - 1 >= 0
   rm(z', z'') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' = 0
   rm(z', z'') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 0, z'' = 1 + (1 + x1) + x
   rm(z', z'') -{ 2 }-> if_rm(0, 1 + (z' - 1), 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' - 1 >= 0
   rm(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' >= 0
   tail(z') -{ 1 }-> x :|: n >= 0, z' = 1 + n + x, x >= 0
   tail(z') -{ 1 }-> 0 :|: z' = 0

Function symbols to be analyzed: {eq}, {tail}, {head}, {null}, {app}, {min,if_min}, {if_rm,rm}, {if2,mins,if}, {minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [1]

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

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

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

   app(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0
   app(z', z'') -{ 1 }-> 1 + n + app(x, z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0
   eq(z', z'') -{ 1 }-> eq(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0
   eq(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' - 1 >= 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   head(z') -{ 1 }-> n :|: n >= 0, z' = 1 + n + x, x >= 0
   head(z') -{ 0 }-> 0 :|: z' >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 5 + m' }-> if2(eq(n'', if_min(s'', 1 + n'' + (1 + m' + x6))), 1 + n'' + (1 + m' + x6), z1, z2) :|: s'' >= 0, s'' <= 1, z2 >= 0, z1 >= 0, m' >= 0, x6 >= 0, n'' >= 0, z'' = 1 + n'' + (1 + m' + x6), z' = 0
   if(z', z'', z1, z2) -{ 2 }-> if2(eq(n'', 0), 1 + n'' + x5, z1, z2) :|: z'' = 1 + n'' + x5, x5 >= 0, z2 >= 0, z1 >= 0, n'' >= 0, z' = 0
   if(z', z'', z1, z2) -{ 4 + m'' }-> if2(eq(0, if_min(s1, 1 + n2 + (1 + m'' + x7))), 1 + n2 + (1 + m'' + x7), z1, z2) :|: s1 >= 0, s1 <= 1, z2 >= 0, m'' >= 0, x7 >= 0, z1 >= 0, z'' = 1 + n2 + (1 + m'' + x7), n2 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 1 }-> if2(eq(0, 0), z'', z1, z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 2 }-> if2(eq(0, z'' - 1), 1 + (z'' - 1) + 0, z1, z2) :|: z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 3 }-> if2(eq(z'' - 1, z'' - 1), 1 + (z'' - 1) + 0, z1, z2) :|: z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(x10, 1 + n5 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(x10, 1 + 0 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 4 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + n3 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + 0 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + n4 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + 0 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, 0), z1), 0, app(z2, 1 + 0 + 0)) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 1
   if2(z', z'', z1, z2) -{ 2 }-> mins(0, 1 + 0 + z1, z2) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 0
   if_min(z', z'') -{ 1 }-> min(1 + m + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 0, m >= 0
   if_min(z', z'') -{ 1 }-> min(1 + n + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 1, m >= 0
   if_min(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   if_rm(z', z'', z1) -{ 1 }-> rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 1, m >= 0
   if_rm(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   if_rm(z', z'', z1) -{ 1 }-> 1 + m + rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 0, m >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 1, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 1 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   min(z') -{ 4 + y' }-> if_min(s', 1 + (1 + x'') + (1 + (1 + y') + x)) :|: s' >= 0, s' <= 1, x >= 0, y' >= 0, z' = 1 + (1 + x'') + (1 + (1 + y') + x), x'' >= 0
   min(z') -{ 2 }-> if_min(1, 1 + 0 + (1 + m + x)) :|: x >= 0, z' = 1 + 0 + (1 + m + x), m >= 0
   min(z') -{ 2 }-> if_min(0, 1 + (1 + x') + (1 + 0 + x)) :|: x' >= 0, x >= 0, z' = 1 + (1 + x') + (1 + 0 + x)
   min(z') -{ 0 }-> 0 :|: z' >= 0
   min(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   mins(z', z'', z1) -{ 2 }-> if(1, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0
   mins(z', z'', z1) -{ 2 }-> if(0, 1 + n' + x4, z'', z1) :|: x4 >= 0, z1 >= 0, z' = 1 + n' + x4, z'' >= 0, n' >= 0
   minsort(z') -{ 1 }-> mins(z', 0, 0) :|: z' >= 0
   null(z') -{ 1 }-> 1 :|: z' = 0
   null(z') -{ 1 }-> 0 :|: n >= 0, z' = 1 + n + x, x >= 0
   rm(z', z'') -{ 2 }-> if_rm(eq(z' - 1, y''), 1 + (z' - 1), 1 + (1 + y'') + x) :|: z'' = 1 + (1 + y'') + x, x >= 0, y'' >= 0, z' - 1 >= 0
   rm(z', z'') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' = 0
   rm(z', z'') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 0, z'' = 1 + (1 + x1) + x
   rm(z', z'') -{ 2 }-> if_rm(0, 1 + (z' - 1), 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' - 1 >= 0
   rm(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' >= 0
   tail(z') -{ 1 }-> x :|: n >= 0, z' = 1 + n + x, x >= 0
   tail(z') -{ 1 }-> 0 :|: z' = 0

Function symbols to be analyzed: {eq}, {tail}, {head}, {null}, {app}, {min,if_min}, {if_rm,rm}, {if2,mins,if}, {minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [1]

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

(27) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   app(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0
   app(z', z'') -{ 1 }-> 1 + n + app(x, z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0
   eq(z', z'') -{ 1 }-> eq(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0
   eq(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' - 1 >= 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   head(z') -{ 1 }-> n :|: n >= 0, z' = 1 + n + x, x >= 0
   head(z') -{ 0 }-> 0 :|: z' >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 5 + m' }-> if2(eq(n'', if_min(s'', 1 + n'' + (1 + m' + x6))), 1 + n'' + (1 + m' + x6), z1, z2) :|: s'' >= 0, s'' <= 1, z2 >= 0, z1 >= 0, m' >= 0, x6 >= 0, n'' >= 0, z'' = 1 + n'' + (1 + m' + x6), z' = 0
   if(z', z'', z1, z2) -{ 2 }-> if2(eq(n'', 0), 1 + n'' + x5, z1, z2) :|: z'' = 1 + n'' + x5, x5 >= 0, z2 >= 0, z1 >= 0, n'' >= 0, z' = 0
   if(z', z'', z1, z2) -{ 4 + m'' }-> if2(eq(0, if_min(s1, 1 + n2 + (1 + m'' + x7))), 1 + n2 + (1 + m'' + x7), z1, z2) :|: s1 >= 0, s1 <= 1, z2 >= 0, m'' >= 0, x7 >= 0, z1 >= 0, z'' = 1 + n2 + (1 + m'' + x7), n2 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 1 }-> if2(eq(0, 0), z'', z1, z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 2 }-> if2(eq(0, z'' - 1), 1 + (z'' - 1) + 0, z1, z2) :|: z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 3 }-> if2(eq(z'' - 1, z'' - 1), 1 + (z'' - 1) + 0, z1, z2) :|: z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(x10, 1 + n5 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(x10, 1 + 0 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 4 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + n3 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + 0 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + n4 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + 0 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, 0), z1), 0, app(z2, 1 + 0 + 0)) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 1
   if2(z', z'', z1, z2) -{ 2 }-> mins(0, 1 + 0 + z1, z2) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 0
   if_min(z', z'') -{ 1 }-> min(1 + m + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 0, m >= 0
   if_min(z', z'') -{ 1 }-> min(1 + n + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 1, m >= 0
   if_min(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   if_rm(z', z'', z1) -{ 1 }-> rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 1, m >= 0
   if_rm(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   if_rm(z', z'', z1) -{ 1 }-> 1 + m + rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 0, m >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 1, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 1 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   min(z') -{ 4 + y' }-> if_min(s', 1 + (1 + x'') + (1 + (1 + y') + x)) :|: s' >= 0, s' <= 1, x >= 0, y' >= 0, z' = 1 + (1 + x'') + (1 + (1 + y') + x), x'' >= 0
   min(z') -{ 2 }-> if_min(1, 1 + 0 + (1 + m + x)) :|: x >= 0, z' = 1 + 0 + (1 + m + x), m >= 0
   min(z') -{ 2 }-> if_min(0, 1 + (1 + x') + (1 + 0 + x)) :|: x' >= 0, x >= 0, z' = 1 + (1 + x') + (1 + 0 + x)
   min(z') -{ 0 }-> 0 :|: z' >= 0
   min(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   mins(z', z'', z1) -{ 2 }-> if(1, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0
   mins(z', z'', z1) -{ 2 }-> if(0, 1 + n' + x4, z'', z1) :|: x4 >= 0, z1 >= 0, z' = 1 + n' + x4, z'' >= 0, n' >= 0
   minsort(z') -{ 1 }-> mins(z', 0, 0) :|: z' >= 0
   null(z') -{ 1 }-> 1 :|: z' = 0
   null(z') -{ 1 }-> 0 :|: n >= 0, z' = 1 + n + x, x >= 0
   rm(z', z'') -{ 2 }-> if_rm(eq(z' - 1, y''), 1 + (z' - 1), 1 + (1 + y'') + x) :|: z'' = 1 + (1 + y'') + x, x >= 0, y'' >= 0, z' - 1 >= 0
   rm(z', z'') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' = 0
   rm(z', z'') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 0, z'' = 1 + (1 + x1) + x
   rm(z', z'') -{ 2 }-> if_rm(0, 1 + (z' - 1), 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' - 1 >= 0
   rm(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' >= 0
   tail(z') -{ 1 }-> x :|: n >= 0, z' = 1 + n + x, x >= 0
   tail(z') -{ 1 }-> 0 :|: z' = 0

Function symbols to be analyzed: {eq}, {tail}, {head}, {null}, {app}, {min,if_min}, {if_rm,rm}, {if2,mins,if}, {minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [1]
  eq: runtime: ?, size: O(1) [1]

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

(29) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   app(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0
   app(z', z'') -{ 1 }-> 1 + n + app(x, z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0
   eq(z', z'') -{ 1 }-> eq(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0
   eq(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' - 1 >= 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   head(z') -{ 1 }-> n :|: n >= 0, z' = 1 + n + x, x >= 0
   head(z') -{ 0 }-> 0 :|: z' >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 5 + m' }-> if2(eq(n'', if_min(s'', 1 + n'' + (1 + m' + x6))), 1 + n'' + (1 + m' + x6), z1, z2) :|: s'' >= 0, s'' <= 1, z2 >= 0, z1 >= 0, m' >= 0, x6 >= 0, n'' >= 0, z'' = 1 + n'' + (1 + m' + x6), z' = 0
   if(z', z'', z1, z2) -{ 2 }-> if2(eq(n'', 0), 1 + n'' + x5, z1, z2) :|: z'' = 1 + n'' + x5, x5 >= 0, z2 >= 0, z1 >= 0, n'' >= 0, z' = 0
   if(z', z'', z1, z2) -{ 4 + m'' }-> if2(eq(0, if_min(s1, 1 + n2 + (1 + m'' + x7))), 1 + n2 + (1 + m'' + x7), z1, z2) :|: s1 >= 0, s1 <= 1, z2 >= 0, m'' >= 0, x7 >= 0, z1 >= 0, z'' = 1 + n2 + (1 + m'' + x7), n2 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 1 }-> if2(eq(0, 0), z'', z1, z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 2 }-> if2(eq(0, z'' - 1), 1 + (z'' - 1) + 0, z1, z2) :|: z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 3 }-> if2(eq(z'' - 1, z'' - 1), 1 + (z'' - 1) + 0, z1, z2) :|: z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(x10, 1 + n5 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(x10, 1 + 0 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 4 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + n3 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + 0 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + n4 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + 0 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, 0), z1), 0, app(z2, 1 + 0 + 0)) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 1
   if2(z', z'', z1, z2) -{ 2 }-> mins(0, 1 + 0 + z1, z2) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 0
   if_min(z', z'') -{ 1 }-> min(1 + m + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 0, m >= 0
   if_min(z', z'') -{ 1 }-> min(1 + n + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 1, m >= 0
   if_min(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   if_rm(z', z'', z1) -{ 1 }-> rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 1, m >= 0
   if_rm(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   if_rm(z', z'', z1) -{ 1 }-> 1 + m + rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 0, m >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 1, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 1 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   min(z') -{ 4 + y' }-> if_min(s', 1 + (1 + x'') + (1 + (1 + y') + x)) :|: s' >= 0, s' <= 1, x >= 0, y' >= 0, z' = 1 + (1 + x'') + (1 + (1 + y') + x), x'' >= 0
   min(z') -{ 2 }-> if_min(1, 1 + 0 + (1 + m + x)) :|: x >= 0, z' = 1 + 0 + (1 + m + x), m >= 0
   min(z') -{ 2 }-> if_min(0, 1 + (1 + x') + (1 + 0 + x)) :|: x' >= 0, x >= 0, z' = 1 + (1 + x') + (1 + 0 + x)
   min(z') -{ 0 }-> 0 :|: z' >= 0
   min(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   mins(z', z'', z1) -{ 2 }-> if(1, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0
   mins(z', z'', z1) -{ 2 }-> if(0, 1 + n' + x4, z'', z1) :|: x4 >= 0, z1 >= 0, z' = 1 + n' + x4, z'' >= 0, n' >= 0
   minsort(z') -{ 1 }-> mins(z', 0, 0) :|: z' >= 0
   null(z') -{ 1 }-> 1 :|: z' = 0
   null(z') -{ 1 }-> 0 :|: n >= 0, z' = 1 + n + x, x >= 0
   rm(z', z'') -{ 2 }-> if_rm(eq(z' - 1, y''), 1 + (z' - 1), 1 + (1 + y'') + x) :|: z'' = 1 + (1 + y'') + x, x >= 0, y'' >= 0, z' - 1 >= 0
   rm(z', z'') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' = 0
   rm(z', z'') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 0, z'' = 1 + (1 + x1) + x
   rm(z', z'') -{ 2 }-> if_rm(0, 1 + (z' - 1), 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' - 1 >= 0
   rm(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' >= 0
   tail(z') -{ 1 }-> x :|: n >= 0, z' = 1 + n + x, x >= 0
   tail(z') -{ 1 }-> 0 :|: z' = 0

Function symbols to be analyzed: {tail}, {head}, {null}, {app}, {min,if_min}, {if_rm,rm}, {if2,mins,if}, {minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]

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

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

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

   app(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0
   app(z', z'') -{ 1 }-> 1 + n + app(x, z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0
   eq(z', z'') -{ 3 + z' }-> s2 :|: s2 >= 0, s2 <= 1, z' - 1 >= 0, z'' - 1 >= 0
   eq(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' - 1 >= 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   head(z') -{ 1 }-> n :|: n >= 0, z' = 1 + n + x, x >= 0
   head(z') -{ 0 }-> 0 :|: z' >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 5 + z'' }-> if2(s4, 1 + (z'' - 1) + 0, z1, z2) :|: s4 >= 0, s4 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + n'' }-> if2(s5, 1 + n'' + x5, z1, z2) :|: s5 >= 0, s5 <= 1, z'' = 1 + n'' + x5, x5 >= 0, z2 >= 0, z1 >= 0, n'' >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 }-> if2(s6, 1 + (z'' - 1) + 0, z1, z2) :|: s6 >= 0, s6 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 4 }-> if2(s7, z'', z1, z2) :|: s7 >= 0, s7 <= 1, z2 >= 0, z'' >= 0, z1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + m' }-> if2(eq(n'', if_min(s'', 1 + n'' + (1 + m' + x6))), 1 + n'' + (1 + m' + x6), z1, z2) :|: s'' >= 0, s'' <= 1, z2 >= 0, z1 >= 0, m' >= 0, x6 >= 0, n'' >= 0, z'' = 1 + n'' + (1 + m' + x6), z' = 0
   if(z', z'', z1, z2) -{ 4 + m'' }-> if2(eq(0, if_min(s1, 1 + n2 + (1 + m'' + x7))), 1 + n2 + (1 + m'' + x7), z1, z2) :|: s1 >= 0, s1 <= 1, z2 >= 0, m'' >= 0, x7 >= 0, z1 >= 0, z'' = 1 + n2 + (1 + m'' + x7), n2 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(x10, 1 + n5 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(x10, 1 + 0 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 4 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + n3 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + 0 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + n4 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + 0 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, 0), z1), 0, app(z2, 1 + 0 + 0)) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 1
   if2(z', z'', z1, z2) -{ 2 }-> mins(0, 1 + 0 + z1, z2) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 0
   if_min(z', z'') -{ 1 }-> min(1 + m + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 0, m >= 0
   if_min(z', z'') -{ 1 }-> min(1 + n + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 1, m >= 0
   if_min(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   if_rm(z', z'', z1) -{ 1 }-> rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 1, m >= 0
   if_rm(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   if_rm(z', z'', z1) -{ 1 }-> 1 + m + rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 0, m >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 1, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 1 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   min(z') -{ 4 + y' }-> if_min(s', 1 + (1 + x'') + (1 + (1 + y') + x)) :|: s' >= 0, s' <= 1, x >= 0, y' >= 0, z' = 1 + (1 + x'') + (1 + (1 + y') + x), x'' >= 0
   min(z') -{ 2 }-> if_min(1, 1 + 0 + (1 + m + x)) :|: x >= 0, z' = 1 + 0 + (1 + m + x), m >= 0
   min(z') -{ 2 }-> if_min(0, 1 + (1 + x') + (1 + 0 + x)) :|: x' >= 0, x >= 0, z' = 1 + (1 + x') + (1 + 0 + x)
   min(z') -{ 0 }-> 0 :|: z' >= 0
   min(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   mins(z', z'', z1) -{ 2 }-> if(1, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0
   mins(z', z'', z1) -{ 2 }-> if(0, 1 + n' + x4, z'', z1) :|: x4 >= 0, z1 >= 0, z' = 1 + n' + x4, z'' >= 0, n' >= 0
   minsort(z') -{ 1 }-> mins(z', 0, 0) :|: z' >= 0
   null(z') -{ 1 }-> 1 :|: z' = 0
   null(z') -{ 1 }-> 0 :|: n >= 0, z' = 1 + n + x, x >= 0
   rm(z', z'') -{ 4 + z' }-> if_rm(s3, 1 + (z' - 1), 1 + (1 + y'') + x) :|: s3 >= 0, s3 <= 1, z'' = 1 + (1 + y'') + x, x >= 0, y'' >= 0, z' - 1 >= 0
   rm(z', z'') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' = 0
   rm(z', z'') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 0, z'' = 1 + (1 + x1) + x
   rm(z', z'') -{ 2 }-> if_rm(0, 1 + (z' - 1), 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' - 1 >= 0
   rm(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' >= 0
   tail(z') -{ 1 }-> x :|: n >= 0, z' = 1 + n + x, x >= 0
   tail(z') -{ 1 }-> 0 :|: z' = 0

Function symbols to be analyzed: {tail}, {head}, {null}, {app}, {min,if_min}, {if_rm,rm}, {if2,mins,if}, {minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]

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

(33) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   app(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0
   app(z', z'') -{ 1 }-> 1 + n + app(x, z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0
   eq(z', z'') -{ 3 + z' }-> s2 :|: s2 >= 0, s2 <= 1, z' - 1 >= 0, z'' - 1 >= 0
   eq(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' - 1 >= 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   head(z') -{ 1 }-> n :|: n >= 0, z' = 1 + n + x, x >= 0
   head(z') -{ 0 }-> 0 :|: z' >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 5 + z'' }-> if2(s4, 1 + (z'' - 1) + 0, z1, z2) :|: s4 >= 0, s4 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + n'' }-> if2(s5, 1 + n'' + x5, z1, z2) :|: s5 >= 0, s5 <= 1, z'' = 1 + n'' + x5, x5 >= 0, z2 >= 0, z1 >= 0, n'' >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 }-> if2(s6, 1 + (z'' - 1) + 0, z1, z2) :|: s6 >= 0, s6 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 4 }-> if2(s7, z'', z1, z2) :|: s7 >= 0, s7 <= 1, z2 >= 0, z'' >= 0, z1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + m' }-> if2(eq(n'', if_min(s'', 1 + n'' + (1 + m' + x6))), 1 + n'' + (1 + m' + x6), z1, z2) :|: s'' >= 0, s'' <= 1, z2 >= 0, z1 >= 0, m' >= 0, x6 >= 0, n'' >= 0, z'' = 1 + n'' + (1 + m' + x6), z' = 0
   if(z', z'', z1, z2) -{ 4 + m'' }-> if2(eq(0, if_min(s1, 1 + n2 + (1 + m'' + x7))), 1 + n2 + (1 + m'' + x7), z1, z2) :|: s1 >= 0, s1 <= 1, z2 >= 0, m'' >= 0, x7 >= 0, z1 >= 0, z'' = 1 + n2 + (1 + m'' + x7), n2 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(x10, 1 + n5 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(x10, 1 + 0 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 4 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + n3 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + 0 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + n4 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + 0 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, 0), z1), 0, app(z2, 1 + 0 + 0)) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 1
   if2(z', z'', z1, z2) -{ 2 }-> mins(0, 1 + 0 + z1, z2) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 0
   if_min(z', z'') -{ 1 }-> min(1 + m + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 0, m >= 0
   if_min(z', z'') -{ 1 }-> min(1 + n + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 1, m >= 0
   if_min(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   if_rm(z', z'', z1) -{ 1 }-> rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 1, m >= 0
   if_rm(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   if_rm(z', z'', z1) -{ 1 }-> 1 + m + rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 0, m >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 1, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 1 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   min(z') -{ 4 + y' }-> if_min(s', 1 + (1 + x'') + (1 + (1 + y') + x)) :|: s' >= 0, s' <= 1, x >= 0, y' >= 0, z' = 1 + (1 + x'') + (1 + (1 + y') + x), x'' >= 0
   min(z') -{ 2 }-> if_min(1, 1 + 0 + (1 + m + x)) :|: x >= 0, z' = 1 + 0 + (1 + m + x), m >= 0
   min(z') -{ 2 }-> if_min(0, 1 + (1 + x') + (1 + 0 + x)) :|: x' >= 0, x >= 0, z' = 1 + (1 + x') + (1 + 0 + x)
   min(z') -{ 0 }-> 0 :|: z' >= 0
   min(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   mins(z', z'', z1) -{ 2 }-> if(1, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0
   mins(z', z'', z1) -{ 2 }-> if(0, 1 + n' + x4, z'', z1) :|: x4 >= 0, z1 >= 0, z' = 1 + n' + x4, z'' >= 0, n' >= 0
   minsort(z') -{ 1 }-> mins(z', 0, 0) :|: z' >= 0
   null(z') -{ 1 }-> 1 :|: z' = 0
   null(z') -{ 1 }-> 0 :|: n >= 0, z' = 1 + n + x, x >= 0
   rm(z', z'') -{ 4 + z' }-> if_rm(s3, 1 + (z' - 1), 1 + (1 + y'') + x) :|: s3 >= 0, s3 <= 1, z'' = 1 + (1 + y'') + x, x >= 0, y'' >= 0, z' - 1 >= 0
   rm(z', z'') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' = 0
   rm(z', z'') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 0, z'' = 1 + (1 + x1) + x
   rm(z', z'') -{ 2 }-> if_rm(0, 1 + (z' - 1), 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' - 1 >= 0
   rm(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' >= 0
   tail(z') -{ 1 }-> x :|: n >= 0, z' = 1 + n + x, x >= 0
   tail(z') -{ 1 }-> 0 :|: z' = 0

Function symbols to be analyzed: {tail}, {head}, {null}, {app}, {min,if_min}, {if_rm,rm}, {if2,mins,if}, {minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: ?, size: O(n^1) [z']

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

(35) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   app(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0
   app(z', z'') -{ 1 }-> 1 + n + app(x, z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0
   eq(z', z'') -{ 3 + z' }-> s2 :|: s2 >= 0, s2 <= 1, z' - 1 >= 0, z'' - 1 >= 0
   eq(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' - 1 >= 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   head(z') -{ 1 }-> n :|: n >= 0, z' = 1 + n + x, x >= 0
   head(z') -{ 0 }-> 0 :|: z' >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 5 + z'' }-> if2(s4, 1 + (z'' - 1) + 0, z1, z2) :|: s4 >= 0, s4 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + n'' }-> if2(s5, 1 + n'' + x5, z1, z2) :|: s5 >= 0, s5 <= 1, z'' = 1 + n'' + x5, x5 >= 0, z2 >= 0, z1 >= 0, n'' >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 }-> if2(s6, 1 + (z'' - 1) + 0, z1, z2) :|: s6 >= 0, s6 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 4 }-> if2(s7, z'', z1, z2) :|: s7 >= 0, s7 <= 1, z2 >= 0, z'' >= 0, z1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + m' }-> if2(eq(n'', if_min(s'', 1 + n'' + (1 + m' + x6))), 1 + n'' + (1 + m' + x6), z1, z2) :|: s'' >= 0, s'' <= 1, z2 >= 0, z1 >= 0, m' >= 0, x6 >= 0, n'' >= 0, z'' = 1 + n'' + (1 + m' + x6), z' = 0
   if(z', z'', z1, z2) -{ 4 + m'' }-> if2(eq(0, if_min(s1, 1 + n2 + (1 + m'' + x7))), 1 + n2 + (1 + m'' + x7), z1, z2) :|: s1 >= 0, s1 <= 1, z2 >= 0, m'' >= 0, x7 >= 0, z1 >= 0, z'' = 1 + n2 + (1 + m'' + x7), n2 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(x10, 1 + n5 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(x10, 1 + 0 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 4 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + n3 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + 0 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + n4 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + 0 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, 0), z1), 0, app(z2, 1 + 0 + 0)) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 1
   if2(z', z'', z1, z2) -{ 2 }-> mins(0, 1 + 0 + z1, z2) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 0
   if_min(z', z'') -{ 1 }-> min(1 + m + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 0, m >= 0
   if_min(z', z'') -{ 1 }-> min(1 + n + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 1, m >= 0
   if_min(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   if_rm(z', z'', z1) -{ 1 }-> rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 1, m >= 0
   if_rm(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   if_rm(z', z'', z1) -{ 1 }-> 1 + m + rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 0, m >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 1, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 1 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   min(z') -{ 4 + y' }-> if_min(s', 1 + (1 + x'') + (1 + (1 + y') + x)) :|: s' >= 0, s' <= 1, x >= 0, y' >= 0, z' = 1 + (1 + x'') + (1 + (1 + y') + x), x'' >= 0
   min(z') -{ 2 }-> if_min(1, 1 + 0 + (1 + m + x)) :|: x >= 0, z' = 1 + 0 + (1 + m + x), m >= 0
   min(z') -{ 2 }-> if_min(0, 1 + (1 + x') + (1 + 0 + x)) :|: x' >= 0, x >= 0, z' = 1 + (1 + x') + (1 + 0 + x)
   min(z') -{ 0 }-> 0 :|: z' >= 0
   min(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   mins(z', z'', z1) -{ 2 }-> if(1, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0
   mins(z', z'', z1) -{ 2 }-> if(0, 1 + n' + x4, z'', z1) :|: x4 >= 0, z1 >= 0, z' = 1 + n' + x4, z'' >= 0, n' >= 0
   minsort(z') -{ 1 }-> mins(z', 0, 0) :|: z' >= 0
   null(z') -{ 1 }-> 1 :|: z' = 0
   null(z') -{ 1 }-> 0 :|: n >= 0, z' = 1 + n + x, x >= 0
   rm(z', z'') -{ 4 + z' }-> if_rm(s3, 1 + (z' - 1), 1 + (1 + y'') + x) :|: s3 >= 0, s3 <= 1, z'' = 1 + (1 + y'') + x, x >= 0, y'' >= 0, z' - 1 >= 0
   rm(z', z'') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' = 0
   rm(z', z'') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 0, z'' = 1 + (1 + x1) + x
   rm(z', z'') -{ 2 }-> if_rm(0, 1 + (z' - 1), 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' - 1 >= 0
   rm(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' >= 0
   tail(z') -{ 1 }-> x :|: n >= 0, z' = 1 + n + x, x >= 0
   tail(z') -{ 1 }-> 0 :|: z' = 0

Function symbols to be analyzed: {head}, {null}, {app}, {min,if_min}, {if_rm,rm}, {if2,mins,if}, {minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: O(1) [1], size: O(n^1) [z']

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

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

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

   app(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0
   app(z', z'') -{ 1 }-> 1 + n + app(x, z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0
   eq(z', z'') -{ 3 + z' }-> s2 :|: s2 >= 0, s2 <= 1, z' - 1 >= 0, z'' - 1 >= 0
   eq(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' - 1 >= 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   head(z') -{ 1 }-> n :|: n >= 0, z' = 1 + n + x, x >= 0
   head(z') -{ 0 }-> 0 :|: z' >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 5 + z'' }-> if2(s4, 1 + (z'' - 1) + 0, z1, z2) :|: s4 >= 0, s4 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + n'' }-> if2(s5, 1 + n'' + x5, z1, z2) :|: s5 >= 0, s5 <= 1, z'' = 1 + n'' + x5, x5 >= 0, z2 >= 0, z1 >= 0, n'' >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 }-> if2(s6, 1 + (z'' - 1) + 0, z1, z2) :|: s6 >= 0, s6 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 4 }-> if2(s7, z'', z1, z2) :|: s7 >= 0, s7 <= 1, z2 >= 0, z'' >= 0, z1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + m' }-> if2(eq(n'', if_min(s'', 1 + n'' + (1 + m' + x6))), 1 + n'' + (1 + m' + x6), z1, z2) :|: s'' >= 0, s'' <= 1, z2 >= 0, z1 >= 0, m' >= 0, x6 >= 0, n'' >= 0, z'' = 1 + n'' + (1 + m' + x6), z' = 0
   if(z', z'', z1, z2) -{ 4 + m'' }-> if2(eq(0, if_min(s1, 1 + n2 + (1 + m'' + x7))), 1 + n2 + (1 + m'' + x7), z1, z2) :|: s1 >= 0, s1 <= 1, z2 >= 0, m'' >= 0, x7 >= 0, z1 >= 0, z'' = 1 + n2 + (1 + m'' + x7), n2 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(x10, 1 + n5 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(x10, 1 + 0 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 4 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + n3 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + 0 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + n4 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + 0 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, 0), z1), 0, app(z2, 1 + 0 + 0)) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 1
   if2(z', z'', z1, z2) -{ 2 }-> mins(0, 1 + 0 + z1, z2) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 0
   if_min(z', z'') -{ 1 }-> min(1 + m + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 0, m >= 0
   if_min(z', z'') -{ 1 }-> min(1 + n + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 1, m >= 0
   if_min(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   if_rm(z', z'', z1) -{ 1 }-> rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 1, m >= 0
   if_rm(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   if_rm(z', z'', z1) -{ 1 }-> 1 + m + rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 0, m >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 1, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 1 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   min(z') -{ 4 + y' }-> if_min(s', 1 + (1 + x'') + (1 + (1 + y') + x)) :|: s' >= 0, s' <= 1, x >= 0, y' >= 0, z' = 1 + (1 + x'') + (1 + (1 + y') + x), x'' >= 0
   min(z') -{ 2 }-> if_min(1, 1 + 0 + (1 + m + x)) :|: x >= 0, z' = 1 + 0 + (1 + m + x), m >= 0
   min(z') -{ 2 }-> if_min(0, 1 + (1 + x') + (1 + 0 + x)) :|: x' >= 0, x >= 0, z' = 1 + (1 + x') + (1 + 0 + x)
   min(z') -{ 0 }-> 0 :|: z' >= 0
   min(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   mins(z', z'', z1) -{ 2 }-> if(1, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0
   mins(z', z'', z1) -{ 2 }-> if(0, 1 + n' + x4, z'', z1) :|: x4 >= 0, z1 >= 0, z' = 1 + n' + x4, z'' >= 0, n' >= 0
   minsort(z') -{ 1 }-> mins(z', 0, 0) :|: z' >= 0
   null(z') -{ 1 }-> 1 :|: z' = 0
   null(z') -{ 1 }-> 0 :|: n >= 0, z' = 1 + n + x, x >= 0
   rm(z', z'') -{ 4 + z' }-> if_rm(s3, 1 + (z' - 1), 1 + (1 + y'') + x) :|: s3 >= 0, s3 <= 1, z'' = 1 + (1 + y'') + x, x >= 0, y'' >= 0, z' - 1 >= 0
   rm(z', z'') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' = 0
   rm(z', z'') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 0, z'' = 1 + (1 + x1) + x
   rm(z', z'') -{ 2 }-> if_rm(0, 1 + (z' - 1), 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' - 1 >= 0
   rm(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' >= 0
   tail(z') -{ 1 }-> x :|: n >= 0, z' = 1 + n + x, x >= 0
   tail(z') -{ 1 }-> 0 :|: z' = 0

Function symbols to be analyzed: {head}, {null}, {app}, {min,if_min}, {if_rm,rm}, {if2,mins,if}, {minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: O(1) [1], size: O(n^1) [z']

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

(39) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   app(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0
   app(z', z'') -{ 1 }-> 1 + n + app(x, z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0
   eq(z', z'') -{ 3 + z' }-> s2 :|: s2 >= 0, s2 <= 1, z' - 1 >= 0, z'' - 1 >= 0
   eq(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' - 1 >= 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   head(z') -{ 1 }-> n :|: n >= 0, z' = 1 + n + x, x >= 0
   head(z') -{ 0 }-> 0 :|: z' >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 5 + z'' }-> if2(s4, 1 + (z'' - 1) + 0, z1, z2) :|: s4 >= 0, s4 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + n'' }-> if2(s5, 1 + n'' + x5, z1, z2) :|: s5 >= 0, s5 <= 1, z'' = 1 + n'' + x5, x5 >= 0, z2 >= 0, z1 >= 0, n'' >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 }-> if2(s6, 1 + (z'' - 1) + 0, z1, z2) :|: s6 >= 0, s6 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 4 }-> if2(s7, z'', z1, z2) :|: s7 >= 0, s7 <= 1, z2 >= 0, z'' >= 0, z1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + m' }-> if2(eq(n'', if_min(s'', 1 + n'' + (1 + m' + x6))), 1 + n'' + (1 + m' + x6), z1, z2) :|: s'' >= 0, s'' <= 1, z2 >= 0, z1 >= 0, m' >= 0, x6 >= 0, n'' >= 0, z'' = 1 + n'' + (1 + m' + x6), z' = 0
   if(z', z'', z1, z2) -{ 4 + m'' }-> if2(eq(0, if_min(s1, 1 + n2 + (1 + m'' + x7))), 1 + n2 + (1 + m'' + x7), z1, z2) :|: s1 >= 0, s1 <= 1, z2 >= 0, m'' >= 0, x7 >= 0, z1 >= 0, z'' = 1 + n2 + (1 + m'' + x7), n2 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(x10, 1 + n5 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(x10, 1 + 0 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 4 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + n3 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + 0 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + n4 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + 0 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, 0), z1), 0, app(z2, 1 + 0 + 0)) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 1
   if2(z', z'', z1, z2) -{ 2 }-> mins(0, 1 + 0 + z1, z2) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 0
   if_min(z', z'') -{ 1 }-> min(1 + m + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 0, m >= 0
   if_min(z', z'') -{ 1 }-> min(1 + n + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 1, m >= 0
   if_min(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   if_rm(z', z'', z1) -{ 1 }-> rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 1, m >= 0
   if_rm(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   if_rm(z', z'', z1) -{ 1 }-> 1 + m + rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 0, m >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 1, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 1 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   min(z') -{ 4 + y' }-> if_min(s', 1 + (1 + x'') + (1 + (1 + y') + x)) :|: s' >= 0, s' <= 1, x >= 0, y' >= 0, z' = 1 + (1 + x'') + (1 + (1 + y') + x), x'' >= 0
   min(z') -{ 2 }-> if_min(1, 1 + 0 + (1 + m + x)) :|: x >= 0, z' = 1 + 0 + (1 + m + x), m >= 0
   min(z') -{ 2 }-> if_min(0, 1 + (1 + x') + (1 + 0 + x)) :|: x' >= 0, x >= 0, z' = 1 + (1 + x') + (1 + 0 + x)
   min(z') -{ 0 }-> 0 :|: z' >= 0
   min(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   mins(z', z'', z1) -{ 2 }-> if(1, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0
   mins(z', z'', z1) -{ 2 }-> if(0, 1 + n' + x4, z'', z1) :|: x4 >= 0, z1 >= 0, z' = 1 + n' + x4, z'' >= 0, n' >= 0
   minsort(z') -{ 1 }-> mins(z', 0, 0) :|: z' >= 0
   null(z') -{ 1 }-> 1 :|: z' = 0
   null(z') -{ 1 }-> 0 :|: n >= 0, z' = 1 + n + x, x >= 0
   rm(z', z'') -{ 4 + z' }-> if_rm(s3, 1 + (z' - 1), 1 + (1 + y'') + x) :|: s3 >= 0, s3 <= 1, z'' = 1 + (1 + y'') + x, x >= 0, y'' >= 0, z' - 1 >= 0
   rm(z', z'') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' = 0
   rm(z', z'') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 0, z'' = 1 + (1 + x1) + x
   rm(z', z'') -{ 2 }-> if_rm(0, 1 + (z' - 1), 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' - 1 >= 0
   rm(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' >= 0
   tail(z') -{ 1 }-> x :|: n >= 0, z' = 1 + n + x, x >= 0
   tail(z') -{ 1 }-> 0 :|: z' = 0

Function symbols to be analyzed: {head}, {null}, {app}, {min,if_min}, {if_rm,rm}, {if2,mins,if}, {minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: O(1) [1], size: O(n^1) [z']
  head: runtime: ?, size: O(n^1) [z']

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

(41) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   app(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0
   app(z', z'') -{ 1 }-> 1 + n + app(x, z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0
   eq(z', z'') -{ 3 + z' }-> s2 :|: s2 >= 0, s2 <= 1, z' - 1 >= 0, z'' - 1 >= 0
   eq(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' - 1 >= 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   head(z') -{ 1 }-> n :|: n >= 0, z' = 1 + n + x, x >= 0
   head(z') -{ 0 }-> 0 :|: z' >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 5 + z'' }-> if2(s4, 1 + (z'' - 1) + 0, z1, z2) :|: s4 >= 0, s4 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + n'' }-> if2(s5, 1 + n'' + x5, z1, z2) :|: s5 >= 0, s5 <= 1, z'' = 1 + n'' + x5, x5 >= 0, z2 >= 0, z1 >= 0, n'' >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 }-> if2(s6, 1 + (z'' - 1) + 0, z1, z2) :|: s6 >= 0, s6 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 4 }-> if2(s7, z'', z1, z2) :|: s7 >= 0, s7 <= 1, z2 >= 0, z'' >= 0, z1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + m' }-> if2(eq(n'', if_min(s'', 1 + n'' + (1 + m' + x6))), 1 + n'' + (1 + m' + x6), z1, z2) :|: s'' >= 0, s'' <= 1, z2 >= 0, z1 >= 0, m' >= 0, x6 >= 0, n'' >= 0, z'' = 1 + n'' + (1 + m' + x6), z' = 0
   if(z', z'', z1, z2) -{ 4 + m'' }-> if2(eq(0, if_min(s1, 1 + n2 + (1 + m'' + x7))), 1 + n2 + (1 + m'' + x7), z1, z2) :|: s1 >= 0, s1 <= 1, z2 >= 0, m'' >= 0, x7 >= 0, z1 >= 0, z'' = 1 + n2 + (1 + m'' + x7), n2 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(x10, 1 + n5 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(x10, 1 + 0 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 4 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + n3 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + 0 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + n4 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + 0 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, 0), z1), 0, app(z2, 1 + 0 + 0)) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 1
   if2(z', z'', z1, z2) -{ 2 }-> mins(0, 1 + 0 + z1, z2) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 0
   if_min(z', z'') -{ 1 }-> min(1 + m + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 0, m >= 0
   if_min(z', z'') -{ 1 }-> min(1 + n + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 1, m >= 0
   if_min(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   if_rm(z', z'', z1) -{ 1 }-> rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 1, m >= 0
   if_rm(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   if_rm(z', z'', z1) -{ 1 }-> 1 + m + rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 0, m >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 1, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 1 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   min(z') -{ 4 + y' }-> if_min(s', 1 + (1 + x'') + (1 + (1 + y') + x)) :|: s' >= 0, s' <= 1, x >= 0, y' >= 0, z' = 1 + (1 + x'') + (1 + (1 + y') + x), x'' >= 0
   min(z') -{ 2 }-> if_min(1, 1 + 0 + (1 + m + x)) :|: x >= 0, z' = 1 + 0 + (1 + m + x), m >= 0
   min(z') -{ 2 }-> if_min(0, 1 + (1 + x') + (1 + 0 + x)) :|: x' >= 0, x >= 0, z' = 1 + (1 + x') + (1 + 0 + x)
   min(z') -{ 0 }-> 0 :|: z' >= 0
   min(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   mins(z', z'', z1) -{ 2 }-> if(1, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0
   mins(z', z'', z1) -{ 2 }-> if(0, 1 + n' + x4, z'', z1) :|: x4 >= 0, z1 >= 0, z' = 1 + n' + x4, z'' >= 0, n' >= 0
   minsort(z') -{ 1 }-> mins(z', 0, 0) :|: z' >= 0
   null(z') -{ 1 }-> 1 :|: z' = 0
   null(z') -{ 1 }-> 0 :|: n >= 0, z' = 1 + n + x, x >= 0
   rm(z', z'') -{ 4 + z' }-> if_rm(s3, 1 + (z' - 1), 1 + (1 + y'') + x) :|: s3 >= 0, s3 <= 1, z'' = 1 + (1 + y'') + x, x >= 0, y'' >= 0, z' - 1 >= 0
   rm(z', z'') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' = 0
   rm(z', z'') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 0, z'' = 1 + (1 + x1) + x
   rm(z', z'') -{ 2 }-> if_rm(0, 1 + (z' - 1), 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' - 1 >= 0
   rm(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' >= 0
   tail(z') -{ 1 }-> x :|: n >= 0, z' = 1 + n + x, x >= 0
   tail(z') -{ 1 }-> 0 :|: z' = 0

Function symbols to be analyzed: {null}, {app}, {min,if_min}, {if_rm,rm}, {if2,mins,if}, {minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: O(1) [1], size: O(n^1) [z']
  head: runtime: O(1) [1], size: O(n^1) [z']

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

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

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

   app(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0
   app(z', z'') -{ 1 }-> 1 + n + app(x, z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0
   eq(z', z'') -{ 3 + z' }-> s2 :|: s2 >= 0, s2 <= 1, z' - 1 >= 0, z'' - 1 >= 0
   eq(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' - 1 >= 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   head(z') -{ 1 }-> n :|: n >= 0, z' = 1 + n + x, x >= 0
   head(z') -{ 0 }-> 0 :|: z' >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 5 + z'' }-> if2(s4, 1 + (z'' - 1) + 0, z1, z2) :|: s4 >= 0, s4 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + n'' }-> if2(s5, 1 + n'' + x5, z1, z2) :|: s5 >= 0, s5 <= 1, z'' = 1 + n'' + x5, x5 >= 0, z2 >= 0, z1 >= 0, n'' >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 }-> if2(s6, 1 + (z'' - 1) + 0, z1, z2) :|: s6 >= 0, s6 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 4 }-> if2(s7, z'', z1, z2) :|: s7 >= 0, s7 <= 1, z2 >= 0, z'' >= 0, z1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + m' }-> if2(eq(n'', if_min(s'', 1 + n'' + (1 + m' + x6))), 1 + n'' + (1 + m' + x6), z1, z2) :|: s'' >= 0, s'' <= 1, z2 >= 0, z1 >= 0, m' >= 0, x6 >= 0, n'' >= 0, z'' = 1 + n'' + (1 + m' + x6), z' = 0
   if(z', z'', z1, z2) -{ 4 + m'' }-> if2(eq(0, if_min(s1, 1 + n2 + (1 + m'' + x7))), 1 + n2 + (1 + m'' + x7), z1, z2) :|: s1 >= 0, s1 <= 1, z2 >= 0, m'' >= 0, x7 >= 0, z1 >= 0, z'' = 1 + n2 + (1 + m'' + x7), n2 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(x10, 1 + n5 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(x10, 1 + 0 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 4 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + n3 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + 0 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + n4 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + 0 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, 0), z1), 0, app(z2, 1 + 0 + 0)) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 1
   if2(z', z'', z1, z2) -{ 2 }-> mins(0, 1 + 0 + z1, z2) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 0
   if_min(z', z'') -{ 1 }-> min(1 + m + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 0, m >= 0
   if_min(z', z'') -{ 1 }-> min(1 + n + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 1, m >= 0
   if_min(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   if_rm(z', z'', z1) -{ 1 }-> rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 1, m >= 0
   if_rm(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   if_rm(z', z'', z1) -{ 1 }-> 1 + m + rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 0, m >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 1, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 1 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   min(z') -{ 4 + y' }-> if_min(s', 1 + (1 + x'') + (1 + (1 + y') + x)) :|: s' >= 0, s' <= 1, x >= 0, y' >= 0, z' = 1 + (1 + x'') + (1 + (1 + y') + x), x'' >= 0
   min(z') -{ 2 }-> if_min(1, 1 + 0 + (1 + m + x)) :|: x >= 0, z' = 1 + 0 + (1 + m + x), m >= 0
   min(z') -{ 2 }-> if_min(0, 1 + (1 + x') + (1 + 0 + x)) :|: x' >= 0, x >= 0, z' = 1 + (1 + x') + (1 + 0 + x)
   min(z') -{ 0 }-> 0 :|: z' >= 0
   min(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   mins(z', z'', z1) -{ 2 }-> if(1, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0
   mins(z', z'', z1) -{ 2 }-> if(0, 1 + n' + x4, z'', z1) :|: x4 >= 0, z1 >= 0, z' = 1 + n' + x4, z'' >= 0, n' >= 0
   minsort(z') -{ 1 }-> mins(z', 0, 0) :|: z' >= 0
   null(z') -{ 1 }-> 1 :|: z' = 0
   null(z') -{ 1 }-> 0 :|: n >= 0, z' = 1 + n + x, x >= 0
   rm(z', z'') -{ 4 + z' }-> if_rm(s3, 1 + (z' - 1), 1 + (1 + y'') + x) :|: s3 >= 0, s3 <= 1, z'' = 1 + (1 + y'') + x, x >= 0, y'' >= 0, z' - 1 >= 0
   rm(z', z'') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' = 0
   rm(z', z'') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 0, z'' = 1 + (1 + x1) + x
   rm(z', z'') -{ 2 }-> if_rm(0, 1 + (z' - 1), 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' - 1 >= 0
   rm(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' >= 0
   tail(z') -{ 1 }-> x :|: n >= 0, z' = 1 + n + x, x >= 0
   tail(z') -{ 1 }-> 0 :|: z' = 0

Function symbols to be analyzed: {null}, {app}, {min,if_min}, {if_rm,rm}, {if2,mins,if}, {minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: O(1) [1], size: O(n^1) [z']
  head: runtime: O(1) [1], size: O(n^1) [z']

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

(45) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using CoFloCo for: null
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:

   app(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0
   app(z', z'') -{ 1 }-> 1 + n + app(x, z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0
   eq(z', z'') -{ 3 + z' }-> s2 :|: s2 >= 0, s2 <= 1, z' - 1 >= 0, z'' - 1 >= 0
   eq(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' - 1 >= 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   head(z') -{ 1 }-> n :|: n >= 0, z' = 1 + n + x, x >= 0
   head(z') -{ 0 }-> 0 :|: z' >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 5 + z'' }-> if2(s4, 1 + (z'' - 1) + 0, z1, z2) :|: s4 >= 0, s4 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + n'' }-> if2(s5, 1 + n'' + x5, z1, z2) :|: s5 >= 0, s5 <= 1, z'' = 1 + n'' + x5, x5 >= 0, z2 >= 0, z1 >= 0, n'' >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 }-> if2(s6, 1 + (z'' - 1) + 0, z1, z2) :|: s6 >= 0, s6 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 4 }-> if2(s7, z'', z1, z2) :|: s7 >= 0, s7 <= 1, z2 >= 0, z'' >= 0, z1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + m' }-> if2(eq(n'', if_min(s'', 1 + n'' + (1 + m' + x6))), 1 + n'' + (1 + m' + x6), z1, z2) :|: s'' >= 0, s'' <= 1, z2 >= 0, z1 >= 0, m' >= 0, x6 >= 0, n'' >= 0, z'' = 1 + n'' + (1 + m' + x6), z' = 0
   if(z', z'', z1, z2) -{ 4 + m'' }-> if2(eq(0, if_min(s1, 1 + n2 + (1 + m'' + x7))), 1 + n2 + (1 + m'' + x7), z1, z2) :|: s1 >= 0, s1 <= 1, z2 >= 0, m'' >= 0, x7 >= 0, z1 >= 0, z'' = 1 + n2 + (1 + m'' + x7), n2 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(x10, 1 + n5 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(x10, 1 + 0 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 4 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + n3 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + 0 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + n4 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + 0 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, 0), z1), 0, app(z2, 1 + 0 + 0)) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 1
   if2(z', z'', z1, z2) -{ 2 }-> mins(0, 1 + 0 + z1, z2) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 0
   if_min(z', z'') -{ 1 }-> min(1 + m + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 0, m >= 0
   if_min(z', z'') -{ 1 }-> min(1 + n + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 1, m >= 0
   if_min(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   if_rm(z', z'', z1) -{ 1 }-> rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 1, m >= 0
   if_rm(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   if_rm(z', z'', z1) -{ 1 }-> 1 + m + rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 0, m >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 1, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 1 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   min(z') -{ 4 + y' }-> if_min(s', 1 + (1 + x'') + (1 + (1 + y') + x)) :|: s' >= 0, s' <= 1, x >= 0, y' >= 0, z' = 1 + (1 + x'') + (1 + (1 + y') + x), x'' >= 0
   min(z') -{ 2 }-> if_min(1, 1 + 0 + (1 + m + x)) :|: x >= 0, z' = 1 + 0 + (1 + m + x), m >= 0
   min(z') -{ 2 }-> if_min(0, 1 + (1 + x') + (1 + 0 + x)) :|: x' >= 0, x >= 0, z' = 1 + (1 + x') + (1 + 0 + x)
   min(z') -{ 0 }-> 0 :|: z' >= 0
   min(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   mins(z', z'', z1) -{ 2 }-> if(1, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0
   mins(z', z'', z1) -{ 2 }-> if(0, 1 + n' + x4, z'', z1) :|: x4 >= 0, z1 >= 0, z' = 1 + n' + x4, z'' >= 0, n' >= 0
   minsort(z') -{ 1 }-> mins(z', 0, 0) :|: z' >= 0
   null(z') -{ 1 }-> 1 :|: z' = 0
   null(z') -{ 1 }-> 0 :|: n >= 0, z' = 1 + n + x, x >= 0
   rm(z', z'') -{ 4 + z' }-> if_rm(s3, 1 + (z' - 1), 1 + (1 + y'') + x) :|: s3 >= 0, s3 <= 1, z'' = 1 + (1 + y'') + x, x >= 0, y'' >= 0, z' - 1 >= 0
   rm(z', z'') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' = 0
   rm(z', z'') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 0, z'' = 1 + (1 + x1) + x
   rm(z', z'') -{ 2 }-> if_rm(0, 1 + (z' - 1), 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' - 1 >= 0
   rm(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' >= 0
   tail(z') -{ 1 }-> x :|: n >= 0, z' = 1 + n + x, x >= 0
   tail(z') -{ 1 }-> 0 :|: z' = 0

Function symbols to be analyzed: {null}, {app}, {min,if_min}, {if_rm,rm}, {if2,mins,if}, {minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: O(1) [1], size: O(n^1) [z']
  head: runtime: O(1) [1], size: O(n^1) [z']
  null: runtime: ?, size: O(1) [1]

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

(47) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   app(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0
   app(z', z'') -{ 1 }-> 1 + n + app(x, z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0
   eq(z', z'') -{ 3 + z' }-> s2 :|: s2 >= 0, s2 <= 1, z' - 1 >= 0, z'' - 1 >= 0
   eq(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' - 1 >= 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   head(z') -{ 1 }-> n :|: n >= 0, z' = 1 + n + x, x >= 0
   head(z') -{ 0 }-> 0 :|: z' >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 5 + z'' }-> if2(s4, 1 + (z'' - 1) + 0, z1, z2) :|: s4 >= 0, s4 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + n'' }-> if2(s5, 1 + n'' + x5, z1, z2) :|: s5 >= 0, s5 <= 1, z'' = 1 + n'' + x5, x5 >= 0, z2 >= 0, z1 >= 0, n'' >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 }-> if2(s6, 1 + (z'' - 1) + 0, z1, z2) :|: s6 >= 0, s6 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 4 }-> if2(s7, z'', z1, z2) :|: s7 >= 0, s7 <= 1, z2 >= 0, z'' >= 0, z1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + m' }-> if2(eq(n'', if_min(s'', 1 + n'' + (1 + m' + x6))), 1 + n'' + (1 + m' + x6), z1, z2) :|: s'' >= 0, s'' <= 1, z2 >= 0, z1 >= 0, m' >= 0, x6 >= 0, n'' >= 0, z'' = 1 + n'' + (1 + m' + x6), z' = 0
   if(z', z'', z1, z2) -{ 4 + m'' }-> if2(eq(0, if_min(s1, 1 + n2 + (1 + m'' + x7))), 1 + n2 + (1 + m'' + x7), z1, z2) :|: s1 >= 0, s1 <= 1, z2 >= 0, m'' >= 0, x7 >= 0, z1 >= 0, z'' = 1 + n2 + (1 + m'' + x7), n2 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(x10, 1 + n5 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(x10, 1 + 0 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 4 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + n3 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + 0 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + n4 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + 0 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, 0), z1), 0, app(z2, 1 + 0 + 0)) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 1
   if2(z', z'', z1, z2) -{ 2 }-> mins(0, 1 + 0 + z1, z2) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 0
   if_min(z', z'') -{ 1 }-> min(1 + m + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 0, m >= 0
   if_min(z', z'') -{ 1 }-> min(1 + n + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 1, m >= 0
   if_min(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   if_rm(z', z'', z1) -{ 1 }-> rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 1, m >= 0
   if_rm(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   if_rm(z', z'', z1) -{ 1 }-> 1 + m + rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 0, m >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 1, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 1 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   min(z') -{ 4 + y' }-> if_min(s', 1 + (1 + x'') + (1 + (1 + y') + x)) :|: s' >= 0, s' <= 1, x >= 0, y' >= 0, z' = 1 + (1 + x'') + (1 + (1 + y') + x), x'' >= 0
   min(z') -{ 2 }-> if_min(1, 1 + 0 + (1 + m + x)) :|: x >= 0, z' = 1 + 0 + (1 + m + x), m >= 0
   min(z') -{ 2 }-> if_min(0, 1 + (1 + x') + (1 + 0 + x)) :|: x' >= 0, x >= 0, z' = 1 + (1 + x') + (1 + 0 + x)
   min(z') -{ 0 }-> 0 :|: z' >= 0
   min(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   mins(z', z'', z1) -{ 2 }-> if(1, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0
   mins(z', z'', z1) -{ 2 }-> if(0, 1 + n' + x4, z'', z1) :|: x4 >= 0, z1 >= 0, z' = 1 + n' + x4, z'' >= 0, n' >= 0
   minsort(z') -{ 1 }-> mins(z', 0, 0) :|: z' >= 0
   null(z') -{ 1 }-> 1 :|: z' = 0
   null(z') -{ 1 }-> 0 :|: n >= 0, z' = 1 + n + x, x >= 0
   rm(z', z'') -{ 4 + z' }-> if_rm(s3, 1 + (z' - 1), 1 + (1 + y'') + x) :|: s3 >= 0, s3 <= 1, z'' = 1 + (1 + y'') + x, x >= 0, y'' >= 0, z' - 1 >= 0
   rm(z', z'') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' = 0
   rm(z', z'') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 0, z'' = 1 + (1 + x1) + x
   rm(z', z'') -{ 2 }-> if_rm(0, 1 + (z' - 1), 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' - 1 >= 0
   rm(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' >= 0
   tail(z') -{ 1 }-> x :|: n >= 0, z' = 1 + n + x, x >= 0
   tail(z') -{ 1 }-> 0 :|: z' = 0

Function symbols to be analyzed: {app}, {min,if_min}, {if_rm,rm}, {if2,mins,if}, {minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: O(1) [1], size: O(n^1) [z']
  head: runtime: O(1) [1], size: O(n^1) [z']
  null: runtime: O(1) [1], size: O(1) [1]

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

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

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

   app(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0
   app(z', z'') -{ 1 }-> 1 + n + app(x, z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0
   eq(z', z'') -{ 3 + z' }-> s2 :|: s2 >= 0, s2 <= 1, z' - 1 >= 0, z'' - 1 >= 0
   eq(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' - 1 >= 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   head(z') -{ 1 }-> n :|: n >= 0, z' = 1 + n + x, x >= 0
   head(z') -{ 0 }-> 0 :|: z' >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 5 + z'' }-> if2(s4, 1 + (z'' - 1) + 0, z1, z2) :|: s4 >= 0, s4 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + n'' }-> if2(s5, 1 + n'' + x5, z1, z2) :|: s5 >= 0, s5 <= 1, z'' = 1 + n'' + x5, x5 >= 0, z2 >= 0, z1 >= 0, n'' >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 }-> if2(s6, 1 + (z'' - 1) + 0, z1, z2) :|: s6 >= 0, s6 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 4 }-> if2(s7, z'', z1, z2) :|: s7 >= 0, s7 <= 1, z2 >= 0, z'' >= 0, z1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + m' }-> if2(eq(n'', if_min(s'', 1 + n'' + (1 + m' + x6))), 1 + n'' + (1 + m' + x6), z1, z2) :|: s'' >= 0, s'' <= 1, z2 >= 0, z1 >= 0, m' >= 0, x6 >= 0, n'' >= 0, z'' = 1 + n'' + (1 + m' + x6), z' = 0
   if(z', z'', z1, z2) -{ 4 + m'' }-> if2(eq(0, if_min(s1, 1 + n2 + (1 + m'' + x7))), 1 + n2 + (1 + m'' + x7), z1, z2) :|: s1 >= 0, s1 <= 1, z2 >= 0, m'' >= 0, x7 >= 0, z1 >= 0, z'' = 1 + n2 + (1 + m'' + x7), n2 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(x10, 1 + n5 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(x10, 1 + 0 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 4 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + n3 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + 0 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + n4 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + 0 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, 0), z1), 0, app(z2, 1 + 0 + 0)) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 1
   if2(z', z'', z1, z2) -{ 2 }-> mins(0, 1 + 0 + z1, z2) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 0
   if_min(z', z'') -{ 1 }-> min(1 + m + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 0, m >= 0
   if_min(z', z'') -{ 1 }-> min(1 + n + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 1, m >= 0
   if_min(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   if_rm(z', z'', z1) -{ 1 }-> rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 1, m >= 0
   if_rm(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   if_rm(z', z'', z1) -{ 1 }-> 1 + m + rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 0, m >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 1, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 1 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   min(z') -{ 4 + y' }-> if_min(s', 1 + (1 + x'') + (1 + (1 + y') + x)) :|: s' >= 0, s' <= 1, x >= 0, y' >= 0, z' = 1 + (1 + x'') + (1 + (1 + y') + x), x'' >= 0
   min(z') -{ 2 }-> if_min(1, 1 + 0 + (1 + m + x)) :|: x >= 0, z' = 1 + 0 + (1 + m + x), m >= 0
   min(z') -{ 2 }-> if_min(0, 1 + (1 + x') + (1 + 0 + x)) :|: x' >= 0, x >= 0, z' = 1 + (1 + x') + (1 + 0 + x)
   min(z') -{ 0 }-> 0 :|: z' >= 0
   min(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   mins(z', z'', z1) -{ 2 }-> if(1, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0
   mins(z', z'', z1) -{ 2 }-> if(0, 1 + n' + x4, z'', z1) :|: x4 >= 0, z1 >= 0, z' = 1 + n' + x4, z'' >= 0, n' >= 0
   minsort(z') -{ 1 }-> mins(z', 0, 0) :|: z' >= 0
   null(z') -{ 1 }-> 1 :|: z' = 0
   null(z') -{ 1 }-> 0 :|: n >= 0, z' = 1 + n + x, x >= 0
   rm(z', z'') -{ 4 + z' }-> if_rm(s3, 1 + (z' - 1), 1 + (1 + y'') + x) :|: s3 >= 0, s3 <= 1, z'' = 1 + (1 + y'') + x, x >= 0, y'' >= 0, z' - 1 >= 0
   rm(z', z'') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' = 0
   rm(z', z'') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 0, z'' = 1 + (1 + x1) + x
   rm(z', z'') -{ 2 }-> if_rm(0, 1 + (z' - 1), 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' - 1 >= 0
   rm(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' >= 0
   tail(z') -{ 1 }-> x :|: n >= 0, z' = 1 + n + x, x >= 0
   tail(z') -{ 1 }-> 0 :|: z' = 0

Function symbols to be analyzed: {app}, {min,if_min}, {if_rm,rm}, {if2,mins,if}, {minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: O(1) [1], size: O(n^1) [z']
  head: runtime: O(1) [1], size: O(n^1) [z']
  null: runtime: O(1) [1], size: O(1) [1]

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

(51) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   app(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0
   app(z', z'') -{ 1 }-> 1 + n + app(x, z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0
   eq(z', z'') -{ 3 + z' }-> s2 :|: s2 >= 0, s2 <= 1, z' - 1 >= 0, z'' - 1 >= 0
   eq(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' - 1 >= 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   head(z') -{ 1 }-> n :|: n >= 0, z' = 1 + n + x, x >= 0
   head(z') -{ 0 }-> 0 :|: z' >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 5 + z'' }-> if2(s4, 1 + (z'' - 1) + 0, z1, z2) :|: s4 >= 0, s4 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + n'' }-> if2(s5, 1 + n'' + x5, z1, z2) :|: s5 >= 0, s5 <= 1, z'' = 1 + n'' + x5, x5 >= 0, z2 >= 0, z1 >= 0, n'' >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 }-> if2(s6, 1 + (z'' - 1) + 0, z1, z2) :|: s6 >= 0, s6 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 4 }-> if2(s7, z'', z1, z2) :|: s7 >= 0, s7 <= 1, z2 >= 0, z'' >= 0, z1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + m' }-> if2(eq(n'', if_min(s'', 1 + n'' + (1 + m' + x6))), 1 + n'' + (1 + m' + x6), z1, z2) :|: s'' >= 0, s'' <= 1, z2 >= 0, z1 >= 0, m' >= 0, x6 >= 0, n'' >= 0, z'' = 1 + n'' + (1 + m' + x6), z' = 0
   if(z', z'', z1, z2) -{ 4 + m'' }-> if2(eq(0, if_min(s1, 1 + n2 + (1 + m'' + x7))), 1 + n2 + (1 + m'' + x7), z1, z2) :|: s1 >= 0, s1 <= 1, z2 >= 0, m'' >= 0, x7 >= 0, z1 >= 0, z'' = 1 + n2 + (1 + m'' + x7), n2 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(x10, 1 + n5 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(x10, 1 + 0 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 4 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + n3 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + 0 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + n4 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + 0 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, 0), z1), 0, app(z2, 1 + 0 + 0)) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 1
   if2(z', z'', z1, z2) -{ 2 }-> mins(0, 1 + 0 + z1, z2) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 0
   if_min(z', z'') -{ 1 }-> min(1 + m + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 0, m >= 0
   if_min(z', z'') -{ 1 }-> min(1 + n + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 1, m >= 0
   if_min(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   if_rm(z', z'', z1) -{ 1 }-> rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 1, m >= 0
   if_rm(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   if_rm(z', z'', z1) -{ 1 }-> 1 + m + rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 0, m >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 1, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 1 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   min(z') -{ 4 + y' }-> if_min(s', 1 + (1 + x'') + (1 + (1 + y') + x)) :|: s' >= 0, s' <= 1, x >= 0, y' >= 0, z' = 1 + (1 + x'') + (1 + (1 + y') + x), x'' >= 0
   min(z') -{ 2 }-> if_min(1, 1 + 0 + (1 + m + x)) :|: x >= 0, z' = 1 + 0 + (1 + m + x), m >= 0
   min(z') -{ 2 }-> if_min(0, 1 + (1 + x') + (1 + 0 + x)) :|: x' >= 0, x >= 0, z' = 1 + (1 + x') + (1 + 0 + x)
   min(z') -{ 0 }-> 0 :|: z' >= 0
   min(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   mins(z', z'', z1) -{ 2 }-> if(1, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0
   mins(z', z'', z1) -{ 2 }-> if(0, 1 + n' + x4, z'', z1) :|: x4 >= 0, z1 >= 0, z' = 1 + n' + x4, z'' >= 0, n' >= 0
   minsort(z') -{ 1 }-> mins(z', 0, 0) :|: z' >= 0
   null(z') -{ 1 }-> 1 :|: z' = 0
   null(z') -{ 1 }-> 0 :|: n >= 0, z' = 1 + n + x, x >= 0
   rm(z', z'') -{ 4 + z' }-> if_rm(s3, 1 + (z' - 1), 1 + (1 + y'') + x) :|: s3 >= 0, s3 <= 1, z'' = 1 + (1 + y'') + x, x >= 0, y'' >= 0, z' - 1 >= 0
   rm(z', z'') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' = 0
   rm(z', z'') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 0, z'' = 1 + (1 + x1) + x
   rm(z', z'') -{ 2 }-> if_rm(0, 1 + (z' - 1), 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' - 1 >= 0
   rm(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' >= 0
   tail(z') -{ 1 }-> x :|: n >= 0, z' = 1 + n + x, x >= 0
   tail(z') -{ 1 }-> 0 :|: z' = 0

Function symbols to be analyzed: {app}, {min,if_min}, {if_rm,rm}, {if2,mins,if}, {minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: O(1) [1], size: O(n^1) [z']
  head: runtime: O(1) [1], size: O(n^1) [z']
  null: runtime: O(1) [1], size: O(1) [1]
  app: runtime: ?, size: O(n^1) [z' + z'']

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

(53) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   app(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0
   app(z', z'') -{ 1 }-> 1 + n + app(x, z'') :|: n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0
   eq(z', z'') -{ 3 + z' }-> s2 :|: s2 >= 0, s2 <= 1, z' - 1 >= 0, z'' - 1 >= 0
   eq(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' - 1 >= 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   head(z') -{ 1 }-> n :|: n >= 0, z' = 1 + n + x, x >= 0
   head(z') -{ 0 }-> 0 :|: z' >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 5 + z'' }-> if2(s4, 1 + (z'' - 1) + 0, z1, z2) :|: s4 >= 0, s4 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + n'' }-> if2(s5, 1 + n'' + x5, z1, z2) :|: s5 >= 0, s5 <= 1, z'' = 1 + n'' + x5, x5 >= 0, z2 >= 0, z1 >= 0, n'' >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 }-> if2(s6, 1 + (z'' - 1) + 0, z1, z2) :|: s6 >= 0, s6 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 4 }-> if2(s7, z'', z1, z2) :|: s7 >= 0, s7 <= 1, z2 >= 0, z'' >= 0, z1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + m' }-> if2(eq(n'', if_min(s'', 1 + n'' + (1 + m' + x6))), 1 + n'' + (1 + m' + x6), z1, z2) :|: s'' >= 0, s'' <= 1, z2 >= 0, z1 >= 0, m' >= 0, x6 >= 0, n'' >= 0, z'' = 1 + n'' + (1 + m' + x6), z' = 0
   if(z', z'', z1, z2) -{ 4 + m'' }-> if2(eq(0, if_min(s1, 1 + n2 + (1 + m'' + x7))), 1 + n2 + (1 + m'' + x7), z1, z2) :|: s1 >= 0, s1 <= 1, z2 >= 0, m'' >= 0, x7 >= 0, z1 >= 0, z'' = 1 + n2 + (1 + m'' + x7), n2 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(x10, 1 + n5 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(x10, 1 + 0 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 4 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + n3 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(n3, x8), z1), 0, app(z2, 1 + 0 + 0)) :|: z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + n4 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, x9), z1), 0, app(z2, 1 + 0 + 0)) :|: n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(app(rm(0, 0), z1), 0, app(z2, 1 + 0 + 0)) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 1
   if2(z', z'', z1, z2) -{ 2 }-> mins(0, 1 + 0 + z1, z2) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 0
   if_min(z', z'') -{ 1 }-> min(1 + m + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 0, m >= 0
   if_min(z', z'') -{ 1 }-> min(1 + n + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 1, m >= 0
   if_min(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   if_rm(z', z'', z1) -{ 1 }-> rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 1, m >= 0
   if_rm(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   if_rm(z', z'', z1) -{ 1 }-> 1 + m + rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 0, m >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 1, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 1 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   min(z') -{ 4 + y' }-> if_min(s', 1 + (1 + x'') + (1 + (1 + y') + x)) :|: s' >= 0, s' <= 1, x >= 0, y' >= 0, z' = 1 + (1 + x'') + (1 + (1 + y') + x), x'' >= 0
   min(z') -{ 2 }-> if_min(1, 1 + 0 + (1 + m + x)) :|: x >= 0, z' = 1 + 0 + (1 + m + x), m >= 0
   min(z') -{ 2 }-> if_min(0, 1 + (1 + x') + (1 + 0 + x)) :|: x' >= 0, x >= 0, z' = 1 + (1 + x') + (1 + 0 + x)
   min(z') -{ 0 }-> 0 :|: z' >= 0
   min(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   mins(z', z'', z1) -{ 2 }-> if(1, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0
   mins(z', z'', z1) -{ 2 }-> if(0, 1 + n' + x4, z'', z1) :|: x4 >= 0, z1 >= 0, z' = 1 + n' + x4, z'' >= 0, n' >= 0
   minsort(z') -{ 1 }-> mins(z', 0, 0) :|: z' >= 0
   null(z') -{ 1 }-> 1 :|: z' = 0
   null(z') -{ 1 }-> 0 :|: n >= 0, z' = 1 + n + x, x >= 0
   rm(z', z'') -{ 4 + z' }-> if_rm(s3, 1 + (z' - 1), 1 + (1 + y'') + x) :|: s3 >= 0, s3 <= 1, z'' = 1 + (1 + y'') + x, x >= 0, y'' >= 0, z' - 1 >= 0
   rm(z', z'') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' = 0
   rm(z', z'') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 0, z'' = 1 + (1 + x1) + x
   rm(z', z'') -{ 2 }-> if_rm(0, 1 + (z' - 1), 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' - 1 >= 0
   rm(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' >= 0
   tail(z') -{ 1 }-> x :|: n >= 0, z' = 1 + n + x, x >= 0
   tail(z') -{ 1 }-> 0 :|: z' = 0

Function symbols to be analyzed: {min,if_min}, {if_rm,rm}, {if2,mins,if}, {minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: O(1) [1], size: O(n^1) [z']
  head: runtime: O(1) [1], size: O(n^1) [z']
  null: runtime: O(1) [1], size: O(1) [1]
  app: runtime: O(n^1) [1 + z'], size: O(n^1) [z' + z'']

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

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

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

   app(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0
   app(z', z'') -{ 2 + x }-> 1 + n + s8 :|: s8 >= 0, s8 <= x + z'', n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0
   eq(z', z'') -{ 3 + z' }-> s2 :|: s2 >= 0, s2 <= 1, z' - 1 >= 0, z'' - 1 >= 0
   eq(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' - 1 >= 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   head(z') -{ 1 }-> n :|: n >= 0, z' = 1 + n + x, x >= 0
   head(z') -{ 0 }-> 0 :|: z' >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 5 + z'' }-> if2(s4, 1 + (z'' - 1) + 0, z1, z2) :|: s4 >= 0, s4 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + n'' }-> if2(s5, 1 + n'' + x5, z1, z2) :|: s5 >= 0, s5 <= 1, z'' = 1 + n'' + x5, x5 >= 0, z2 >= 0, z1 >= 0, n'' >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 }-> if2(s6, 1 + (z'' - 1) + 0, z1, z2) :|: s6 >= 0, s6 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 4 }-> if2(s7, z'', z1, z2) :|: s7 >= 0, s7 <= 1, z2 >= 0, z'' >= 0, z1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + m' }-> if2(eq(n'', if_min(s'', 1 + n'' + (1 + m' + x6))), 1 + n'' + (1 + m' + x6), z1, z2) :|: s'' >= 0, s'' <= 1, z2 >= 0, z1 >= 0, m' >= 0, x6 >= 0, n'' >= 0, z'' = 1 + n'' + (1 + m' + x6), z' = 0
   if(z', z'', z1, z2) -{ 4 + m'' }-> if2(eq(0, if_min(s1, 1 + n2 + (1 + m'' + x7))), 1 + n2 + (1 + m'' + x7), z1, z2) :|: s1 >= 0, s1 <= 1, z2 >= 0, m'' >= 0, x7 >= 0, z1 >= 0, z'' = 1 + n2 + (1 + m'' + x7), n2 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(x10, 1 + n5 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(x10, 1 + 0 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 4 + z2 }-> mins(app(rm(n3, x8), z1), 0, s10) :|: s10 >= 0, s10 <= z2 + (1 + 0 + 0), z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 5 + z2 }-> mins(app(rm(n3, x8), z1), 0, s9) :|: s9 >= 0, s9 <= z2 + (1 + n3 + 0), z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 4 + z2 }-> mins(app(rm(0, x9), z1), 0, s11) :|: s11 >= 0, s11 <= z2 + (1 + n4 + 0), n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 3 + z2 }-> mins(app(rm(0, x9), z1), 0, s12) :|: s12 >= 0, s12 <= z2 + (1 + 0 + 0), n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 3 + z2 }-> mins(app(rm(0, 0), z1), 0, s13) :|: s13 >= 0, s13 <= z2 + (1 + 0 + 0), z'' = 0, z2 >= 0, z1 >= 0, z' = 1
   if2(z', z'', z1, z2) -{ 2 }-> mins(0, 1 + 0 + z1, z2) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 0
   if_min(z', z'') -{ 1 }-> min(1 + m + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 0, m >= 0
   if_min(z', z'') -{ 1 }-> min(1 + n + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 1, m >= 0
   if_min(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   if_rm(z', z'', z1) -{ 1 }-> rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 1, m >= 0
   if_rm(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   if_rm(z', z'', z1) -{ 1 }-> 1 + m + rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 0, m >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 1, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 1 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   min(z') -{ 4 + y' }-> if_min(s', 1 + (1 + x'') + (1 + (1 + y') + x)) :|: s' >= 0, s' <= 1, x >= 0, y' >= 0, z' = 1 + (1 + x'') + (1 + (1 + y') + x), x'' >= 0
   min(z') -{ 2 }-> if_min(1, 1 + 0 + (1 + m + x)) :|: x >= 0, z' = 1 + 0 + (1 + m + x), m >= 0
   min(z') -{ 2 }-> if_min(0, 1 + (1 + x') + (1 + 0 + x)) :|: x' >= 0, x >= 0, z' = 1 + (1 + x') + (1 + 0 + x)
   min(z') -{ 0 }-> 0 :|: z' >= 0
   min(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   mins(z', z'', z1) -{ 2 }-> if(1, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0
   mins(z', z'', z1) -{ 2 }-> if(0, 1 + n' + x4, z'', z1) :|: x4 >= 0, z1 >= 0, z' = 1 + n' + x4, z'' >= 0, n' >= 0
   minsort(z') -{ 1 }-> mins(z', 0, 0) :|: z' >= 0
   null(z') -{ 1 }-> 1 :|: z' = 0
   null(z') -{ 1 }-> 0 :|: n >= 0, z' = 1 + n + x, x >= 0
   rm(z', z'') -{ 4 + z' }-> if_rm(s3, 1 + (z' - 1), 1 + (1 + y'') + x) :|: s3 >= 0, s3 <= 1, z'' = 1 + (1 + y'') + x, x >= 0, y'' >= 0, z' - 1 >= 0
   rm(z', z'') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' = 0
   rm(z', z'') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 0, z'' = 1 + (1 + x1) + x
   rm(z', z'') -{ 2 }-> if_rm(0, 1 + (z' - 1), 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' - 1 >= 0
   rm(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' >= 0
   tail(z') -{ 1 }-> x :|: n >= 0, z' = 1 + n + x, x >= 0
   tail(z') -{ 1 }-> 0 :|: z' = 0

Function symbols to be analyzed: {min,if_min}, {if_rm,rm}, {if2,mins,if}, {minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: O(1) [1], size: O(n^1) [z']
  head: runtime: O(1) [1], size: O(n^1) [z']
  null: runtime: O(1) [1], size: O(1) [1]
  app: runtime: O(n^1) [1 + z'], size: O(n^1) [z' + z'']

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

(57) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

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

   app(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0
   app(z', z'') -{ 2 + x }-> 1 + n + s8 :|: s8 >= 0, s8 <= x + z'', n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0
   eq(z', z'') -{ 3 + z' }-> s2 :|: s2 >= 0, s2 <= 1, z' - 1 >= 0, z'' - 1 >= 0
   eq(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' - 1 >= 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   head(z') -{ 1 }-> n :|: n >= 0, z' = 1 + n + x, x >= 0
   head(z') -{ 0 }-> 0 :|: z' >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 5 + z'' }-> if2(s4, 1 + (z'' - 1) + 0, z1, z2) :|: s4 >= 0, s4 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + n'' }-> if2(s5, 1 + n'' + x5, z1, z2) :|: s5 >= 0, s5 <= 1, z'' = 1 + n'' + x5, x5 >= 0, z2 >= 0, z1 >= 0, n'' >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 }-> if2(s6, 1 + (z'' - 1) + 0, z1, z2) :|: s6 >= 0, s6 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 4 }-> if2(s7, z'', z1, z2) :|: s7 >= 0, s7 <= 1, z2 >= 0, z'' >= 0, z1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + m' }-> if2(eq(n'', if_min(s'', 1 + n'' + (1 + m' + x6))), 1 + n'' + (1 + m' + x6), z1, z2) :|: s'' >= 0, s'' <= 1, z2 >= 0, z1 >= 0, m' >= 0, x6 >= 0, n'' >= 0, z'' = 1 + n'' + (1 + m' + x6), z' = 0
   if(z', z'', z1, z2) -{ 4 + m'' }-> if2(eq(0, if_min(s1, 1 + n2 + (1 + m'' + x7))), 1 + n2 + (1 + m'' + x7), z1, z2) :|: s1 >= 0, s1 <= 1, z2 >= 0, m'' >= 0, x7 >= 0, z1 >= 0, z'' = 1 + n2 + (1 + m'' + x7), n2 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(x10, 1 + n5 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(x10, 1 + 0 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 4 + z2 }-> mins(app(rm(n3, x8), z1), 0, s10) :|: s10 >= 0, s10 <= z2 + (1 + 0 + 0), z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 5 + z2 }-> mins(app(rm(n3, x8), z1), 0, s9) :|: s9 >= 0, s9 <= z2 + (1 + n3 + 0), z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 4 + z2 }-> mins(app(rm(0, x9), z1), 0, s11) :|: s11 >= 0, s11 <= z2 + (1 + n4 + 0), n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 3 + z2 }-> mins(app(rm(0, x9), z1), 0, s12) :|: s12 >= 0, s12 <= z2 + (1 + 0 + 0), n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 3 + z2 }-> mins(app(rm(0, 0), z1), 0, s13) :|: s13 >= 0, s13 <= z2 + (1 + 0 + 0), z'' = 0, z2 >= 0, z1 >= 0, z' = 1
   if2(z', z'', z1, z2) -{ 2 }-> mins(0, 1 + 0 + z1, z2) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 0
   if_min(z', z'') -{ 1 }-> min(1 + m + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 0, m >= 0
   if_min(z', z'') -{ 1 }-> min(1 + n + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 1, m >= 0
   if_min(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   if_rm(z', z'', z1) -{ 1 }-> rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 1, m >= 0
   if_rm(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   if_rm(z', z'', z1) -{ 1 }-> 1 + m + rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 0, m >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 1, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 1 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   min(z') -{ 4 + y' }-> if_min(s', 1 + (1 + x'') + (1 + (1 + y') + x)) :|: s' >= 0, s' <= 1, x >= 0, y' >= 0, z' = 1 + (1 + x'') + (1 + (1 + y') + x), x'' >= 0
   min(z') -{ 2 }-> if_min(1, 1 + 0 + (1 + m + x)) :|: x >= 0, z' = 1 + 0 + (1 + m + x), m >= 0
   min(z') -{ 2 }-> if_min(0, 1 + (1 + x') + (1 + 0 + x)) :|: x' >= 0, x >= 0, z' = 1 + (1 + x') + (1 + 0 + x)
   min(z') -{ 0 }-> 0 :|: z' >= 0
   min(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   mins(z', z'', z1) -{ 2 }-> if(1, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0
   mins(z', z'', z1) -{ 2 }-> if(0, 1 + n' + x4, z'', z1) :|: x4 >= 0, z1 >= 0, z' = 1 + n' + x4, z'' >= 0, n' >= 0
   minsort(z') -{ 1 }-> mins(z', 0, 0) :|: z' >= 0
   null(z') -{ 1 }-> 1 :|: z' = 0
   null(z') -{ 1 }-> 0 :|: n >= 0, z' = 1 + n + x, x >= 0
   rm(z', z'') -{ 4 + z' }-> if_rm(s3, 1 + (z' - 1), 1 + (1 + y'') + x) :|: s3 >= 0, s3 <= 1, z'' = 1 + (1 + y'') + x, x >= 0, y'' >= 0, z' - 1 >= 0
   rm(z', z'') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' = 0
   rm(z', z'') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 0, z'' = 1 + (1 + x1) + x
   rm(z', z'') -{ 2 }-> if_rm(0, 1 + (z' - 1), 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' - 1 >= 0
   rm(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' >= 0
   tail(z') -{ 1 }-> x :|: n >= 0, z' = 1 + n + x, x >= 0
   tail(z') -{ 1 }-> 0 :|: z' = 0

Function symbols to be analyzed: {min,if_min}, {if_rm,rm}, {if2,mins,if}, {minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: O(1) [1], size: O(n^1) [z']
  head: runtime: O(1) [1], size: O(n^1) [z']
  null: runtime: O(1) [1], size: O(1) [1]
  app: runtime: O(n^1) [1 + z'], size: O(n^1) [z' + z'']
  min: runtime: ?, size: O(n^1) [z']
  if_min: runtime: ?, size: O(n^1) [z'']

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

(59) IntTrsBoundProof (UPPER BOUND(ID))

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

Computed RUNTIME bound using KoAT for: if_min
after applying outer abstraction to obtain an ITS,
resulting in: O(n^2) with polynomial bound: 22 + 24*z'' + 8*z''^2

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

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

   app(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0
   app(z', z'') -{ 2 + x }-> 1 + n + s8 :|: s8 >= 0, s8 <= x + z'', n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0
   eq(z', z'') -{ 3 + z' }-> s2 :|: s2 >= 0, s2 <= 1, z' - 1 >= 0, z'' - 1 >= 0
   eq(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' - 1 >= 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   head(z') -{ 1 }-> n :|: n >= 0, z' = 1 + n + x, x >= 0
   head(z') -{ 0 }-> 0 :|: z' >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 5 + z'' }-> if2(s4, 1 + (z'' - 1) + 0, z1, z2) :|: s4 >= 0, s4 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + n'' }-> if2(s5, 1 + n'' + x5, z1, z2) :|: s5 >= 0, s5 <= 1, z'' = 1 + n'' + x5, x5 >= 0, z2 >= 0, z1 >= 0, n'' >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 }-> if2(s6, 1 + (z'' - 1) + 0, z1, z2) :|: s6 >= 0, s6 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 4 }-> if2(s7, z'', z1, z2) :|: s7 >= 0, s7 <= 1, z2 >= 0, z'' >= 0, z1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + m' }-> if2(eq(n'', if_min(s'', 1 + n'' + (1 + m' + x6))), 1 + n'' + (1 + m' + x6), z1, z2) :|: s'' >= 0, s'' <= 1, z2 >= 0, z1 >= 0, m' >= 0, x6 >= 0, n'' >= 0, z'' = 1 + n'' + (1 + m' + x6), z' = 0
   if(z', z'', z1, z2) -{ 4 + m'' }-> if2(eq(0, if_min(s1, 1 + n2 + (1 + m'' + x7))), 1 + n2 + (1 + m'' + x7), z1, z2) :|: s1 >= 0, s1 <= 1, z2 >= 0, m'' >= 0, x7 >= 0, z1 >= 0, z'' = 1 + n2 + (1 + m'' + x7), n2 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(x10, 1 + n5 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(x10, 1 + 0 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 4 + z2 }-> mins(app(rm(n3, x8), z1), 0, s10) :|: s10 >= 0, s10 <= z2 + (1 + 0 + 0), z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 5 + z2 }-> mins(app(rm(n3, x8), z1), 0, s9) :|: s9 >= 0, s9 <= z2 + (1 + n3 + 0), z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 4 + z2 }-> mins(app(rm(0, x9), z1), 0, s11) :|: s11 >= 0, s11 <= z2 + (1 + n4 + 0), n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 3 + z2 }-> mins(app(rm(0, x9), z1), 0, s12) :|: s12 >= 0, s12 <= z2 + (1 + 0 + 0), n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 3 + z2 }-> mins(app(rm(0, 0), z1), 0, s13) :|: s13 >= 0, s13 <= z2 + (1 + 0 + 0), z'' = 0, z2 >= 0, z1 >= 0, z' = 1
   if2(z', z'', z1, z2) -{ 2 }-> mins(0, 1 + 0 + z1, z2) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 0
   if_min(z', z'') -{ 1 }-> min(1 + m + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 0, m >= 0
   if_min(z', z'') -{ 1 }-> min(1 + n + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 1, m >= 0
   if_min(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   if_rm(z', z'', z1) -{ 1 }-> rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 1, m >= 0
   if_rm(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   if_rm(z', z'', z1) -{ 1 }-> 1 + m + rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 0, m >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 1, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 1 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   min(z') -{ 4 + y' }-> if_min(s', 1 + (1 + x'') + (1 + (1 + y') + x)) :|: s' >= 0, s' <= 1, x >= 0, y' >= 0, z' = 1 + (1 + x'') + (1 + (1 + y') + x), x'' >= 0
   min(z') -{ 2 }-> if_min(1, 1 + 0 + (1 + m + x)) :|: x >= 0, z' = 1 + 0 + (1 + m + x), m >= 0
   min(z') -{ 2 }-> if_min(0, 1 + (1 + x') + (1 + 0 + x)) :|: x' >= 0, x >= 0, z' = 1 + (1 + x') + (1 + 0 + x)
   min(z') -{ 0 }-> 0 :|: z' >= 0
   min(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   mins(z', z'', z1) -{ 2 }-> if(1, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0
   mins(z', z'', z1) -{ 2 }-> if(0, 1 + n' + x4, z'', z1) :|: x4 >= 0, z1 >= 0, z' = 1 + n' + x4, z'' >= 0, n' >= 0
   minsort(z') -{ 1 }-> mins(z', 0, 0) :|: z' >= 0
   null(z') -{ 1 }-> 1 :|: z' = 0
   null(z') -{ 1 }-> 0 :|: n >= 0, z' = 1 + n + x, x >= 0
   rm(z', z'') -{ 4 + z' }-> if_rm(s3, 1 + (z' - 1), 1 + (1 + y'') + x) :|: s3 >= 0, s3 <= 1, z'' = 1 + (1 + y'') + x, x >= 0, y'' >= 0, z' - 1 >= 0
   rm(z', z'') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' = 0
   rm(z', z'') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 0, z'' = 1 + (1 + x1) + x
   rm(z', z'') -{ 2 }-> if_rm(0, 1 + (z' - 1), 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' - 1 >= 0
   rm(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' >= 0
   tail(z') -{ 1 }-> x :|: n >= 0, z' = 1 + n + x, x >= 0
   tail(z') -{ 1 }-> 0 :|: z' = 0

Function symbols to be analyzed: {if_rm,rm}, {if2,mins,if}, {minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: O(1) [1], size: O(n^1) [z']
  head: runtime: O(1) [1], size: O(n^1) [z']
  null: runtime: O(1) [1], size: O(1) [1]
  app: runtime: O(n^1) [1 + z'], size: O(n^1) [z' + z'']
  min: runtime: O(n^2) [5 + 4*z' + z'^2], size: O(n^1) [z']
  if_min: runtime: O(n^2) [22 + 24*z'' + 8*z''^2], size: O(n^1) [z'']

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

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

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

   app(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0
   app(z', z'') -{ 2 + x }-> 1 + n + s8 :|: s8 >= 0, s8 <= x + z'', n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0
   eq(z', z'') -{ 3 + z' }-> s2 :|: s2 >= 0, s2 <= 1, z' - 1 >= 0, z'' - 1 >= 0
   eq(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' - 1 >= 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   head(z') -{ 1 }-> n :|: n >= 0, z' = 1 + n + x, x >= 0
   head(z') -{ 0 }-> 0 :|: z' >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 110 + 57*m' + 16*m'*n'' + 16*m'*x6 + 8*m'^2 + 57*n'' + 16*n''*x6 + 8*n''^2 + 56*x6 + 8*x6^2 }-> if2(s20, 1 + n'' + (1 + m' + x6), z1, z2) :|: s19 >= 0, s19 <= 1 + n'' + (1 + m' + x6), s20 >= 0, s20 <= 1, s'' >= 0, s'' <= 1, z2 >= 0, z1 >= 0, m' >= 0, x6 >= 0, n'' >= 0, z'' = 1 + n'' + (1 + m' + x6), z' = 0
   if(z', z'', z1, z2) -{ 109 + 57*m'' + 16*m''*n2 + 16*m''*x7 + 8*m''^2 + 56*n2 + 16*n2*x7 + 8*n2^2 + 56*x7 + 8*x7^2 }-> if2(s22, 1 + n2 + (1 + m'' + x7), z1, z2) :|: s21 >= 0, s21 <= 1 + n2 + (1 + m'' + x7), s22 >= 0, s22 <= 1, s1 >= 0, s1 <= 1, z2 >= 0, m'' >= 0, x7 >= 0, z1 >= 0, z'' = 1 + n2 + (1 + m'' + x7), n2 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + z'' }-> if2(s4, 1 + (z'' - 1) + 0, z1, z2) :|: s4 >= 0, s4 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + n'' }-> if2(s5, 1 + n'' + x5, z1, z2) :|: s5 >= 0, s5 <= 1, z'' = 1 + n'' + x5, x5 >= 0, z2 >= 0, z1 >= 0, n'' >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 }-> if2(s6, 1 + (z'' - 1) + 0, z1, z2) :|: s6 >= 0, s6 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 4 }-> if2(s7, z'', z1, z2) :|: s7 >= 0, s7 <= 1, z2 >= 0, z'' >= 0, z1 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(x10, 1 + n5 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(x10, 1 + 0 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 4 + z2 }-> mins(app(rm(n3, x8), z1), 0, s10) :|: s10 >= 0, s10 <= z2 + (1 + 0 + 0), z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 5 + z2 }-> mins(app(rm(n3, x8), z1), 0, s9) :|: s9 >= 0, s9 <= z2 + (1 + n3 + 0), z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 4 + z2 }-> mins(app(rm(0, x9), z1), 0, s11) :|: s11 >= 0, s11 <= z2 + (1 + n4 + 0), n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 3 + z2 }-> mins(app(rm(0, x9), z1), 0, s12) :|: s12 >= 0, s12 <= z2 + (1 + 0 + 0), n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 3 + z2 }-> mins(app(rm(0, 0), z1), 0, s13) :|: s13 >= 0, s13 <= z2 + (1 + 0 + 0), z'' = 0, z2 >= 0, z1 >= 0, z' = 1
   if2(z', z'', z1, z2) -{ 2 }-> mins(0, 1 + 0 + z1, z2) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 0
   if_min(z', z'') -{ 11 + 6*n + 2*n*x + n^2 + 6*x + x^2 }-> s17 :|: s17 >= 0, s17 <= 1 + n + x, z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 1, m >= 0
   if_min(z', z'') -{ 11 + 6*m + 2*m*x + m^2 + 6*x + x^2 }-> s18 :|: s18 >= 0, s18 <= 1 + m + x, z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 0, m >= 0
   if_min(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   if_rm(z', z'', z1) -{ 1 }-> rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 1, m >= 0
   if_rm(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   if_rm(z', z'', z1) -{ 1 }-> 1 + m + rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 0, m >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 1, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 1 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   min(z') -{ 104 + 56*m + 16*m*x + 8*m^2 + 56*x + 8*x^2 }-> s14 :|: s14 >= 0, s14 <= 1 + 0 + (1 + m + x), x >= 0, z' = 1 + 0 + (1 + m + x), m >= 0
   min(z') -{ 168 + 72*x + 16*x*x' + 8*x^2 + 72*x' + 8*x'^2 }-> s15 :|: s15 >= 0, s15 <= 1 + (1 + x') + (1 + 0 + x), x' >= 0, x >= 0, z' = 1 + (1 + x') + (1 + 0 + x)
   min(z') -{ 250 + 88*x + 16*x*x'' + 16*x*y' + 8*x^2 + 88*x'' + 16*x''*y' + 8*x''^2 + 89*y' + 8*y'^2 }-> s16 :|: s16 >= 0, s16 <= 1 + (1 + x'') + (1 + (1 + y') + x), s' >= 0, s' <= 1, x >= 0, y' >= 0, z' = 1 + (1 + x'') + (1 + (1 + y') + x), x'' >= 0
   min(z') -{ 0 }-> 0 :|: z' >= 0
   min(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   mins(z', z'', z1) -{ 2 }-> if(1, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0
   mins(z', z'', z1) -{ 2 }-> if(0, 1 + n' + x4, z'', z1) :|: x4 >= 0, z1 >= 0, z' = 1 + n' + x4, z'' >= 0, n' >= 0
   minsort(z') -{ 1 }-> mins(z', 0, 0) :|: z' >= 0
   null(z') -{ 1 }-> 1 :|: z' = 0
   null(z') -{ 1 }-> 0 :|: n >= 0, z' = 1 + n + x, x >= 0
   rm(z', z'') -{ 4 + z' }-> if_rm(s3, 1 + (z' - 1), 1 + (1 + y'') + x) :|: s3 >= 0, s3 <= 1, z'' = 1 + (1 + y'') + x, x >= 0, y'' >= 0, z' - 1 >= 0
   rm(z', z'') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' = 0
   rm(z', z'') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 0, z'' = 1 + (1 + x1) + x
   rm(z', z'') -{ 2 }-> if_rm(0, 1 + (z' - 1), 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' - 1 >= 0
   rm(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' >= 0
   tail(z') -{ 1 }-> x :|: n >= 0, z' = 1 + n + x, x >= 0
   tail(z') -{ 1 }-> 0 :|: z' = 0

Function symbols to be analyzed: {if_rm,rm}, {if2,mins,if}, {minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: O(1) [1], size: O(n^1) [z']
  head: runtime: O(1) [1], size: O(n^1) [z']
  null: runtime: O(1) [1], size: O(1) [1]
  app: runtime: O(n^1) [1 + z'], size: O(n^1) [z' + z'']
  min: runtime: O(n^2) [5 + 4*z' + z'^2], size: O(n^1) [z']
  if_min: runtime: O(n^2) [22 + 24*z'' + 8*z''^2], size: O(n^1) [z'']

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

(63) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using KoAT for: if_rm
after applying outer abstraction to obtain an ITS,
resulting in: O(n^1) with polynomial bound: z1

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

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

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

   app(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0
   app(z', z'') -{ 2 + x }-> 1 + n + s8 :|: s8 >= 0, s8 <= x + z'', n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0
   eq(z', z'') -{ 3 + z' }-> s2 :|: s2 >= 0, s2 <= 1, z' - 1 >= 0, z'' - 1 >= 0
   eq(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' - 1 >= 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   head(z') -{ 1 }-> n :|: n >= 0, z' = 1 + n + x, x >= 0
   head(z') -{ 0 }-> 0 :|: z' >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 110 + 57*m' + 16*m'*n'' + 16*m'*x6 + 8*m'^2 + 57*n'' + 16*n''*x6 + 8*n''^2 + 56*x6 + 8*x6^2 }-> if2(s20, 1 + n'' + (1 + m' + x6), z1, z2) :|: s19 >= 0, s19 <= 1 + n'' + (1 + m' + x6), s20 >= 0, s20 <= 1, s'' >= 0, s'' <= 1, z2 >= 0, z1 >= 0, m' >= 0, x6 >= 0, n'' >= 0, z'' = 1 + n'' + (1 + m' + x6), z' = 0
   if(z', z'', z1, z2) -{ 109 + 57*m'' + 16*m''*n2 + 16*m''*x7 + 8*m''^2 + 56*n2 + 16*n2*x7 + 8*n2^2 + 56*x7 + 8*x7^2 }-> if2(s22, 1 + n2 + (1 + m'' + x7), z1, z2) :|: s21 >= 0, s21 <= 1 + n2 + (1 + m'' + x7), s22 >= 0, s22 <= 1, s1 >= 0, s1 <= 1, z2 >= 0, m'' >= 0, x7 >= 0, z1 >= 0, z'' = 1 + n2 + (1 + m'' + x7), n2 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + z'' }-> if2(s4, 1 + (z'' - 1) + 0, z1, z2) :|: s4 >= 0, s4 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + n'' }-> if2(s5, 1 + n'' + x5, z1, z2) :|: s5 >= 0, s5 <= 1, z'' = 1 + n'' + x5, x5 >= 0, z2 >= 0, z1 >= 0, n'' >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 }-> if2(s6, 1 + (z'' - 1) + 0, z1, z2) :|: s6 >= 0, s6 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 4 }-> if2(s7, z'', z1, z2) :|: s7 >= 0, s7 <= 1, z2 >= 0, z'' >= 0, z1 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(x10, 1 + n5 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(x10, 1 + 0 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 4 + z2 }-> mins(app(rm(n3, x8), z1), 0, s10) :|: s10 >= 0, s10 <= z2 + (1 + 0 + 0), z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 5 + z2 }-> mins(app(rm(n3, x8), z1), 0, s9) :|: s9 >= 0, s9 <= z2 + (1 + n3 + 0), z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 4 + z2 }-> mins(app(rm(0, x9), z1), 0, s11) :|: s11 >= 0, s11 <= z2 + (1 + n4 + 0), n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 3 + z2 }-> mins(app(rm(0, x9), z1), 0, s12) :|: s12 >= 0, s12 <= z2 + (1 + 0 + 0), n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 3 + z2 }-> mins(app(rm(0, 0), z1), 0, s13) :|: s13 >= 0, s13 <= z2 + (1 + 0 + 0), z'' = 0, z2 >= 0, z1 >= 0, z' = 1
   if2(z', z'', z1, z2) -{ 2 }-> mins(0, 1 + 0 + z1, z2) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 0
   if_min(z', z'') -{ 11 + 6*n + 2*n*x + n^2 + 6*x + x^2 }-> s17 :|: s17 >= 0, s17 <= 1 + n + x, z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 1, m >= 0
   if_min(z', z'') -{ 11 + 6*m + 2*m*x + m^2 + 6*x + x^2 }-> s18 :|: s18 >= 0, s18 <= 1 + m + x, z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 0, m >= 0
   if_min(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   if_rm(z', z'', z1) -{ 1 }-> rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 1, m >= 0
   if_rm(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   if_rm(z', z'', z1) -{ 1 }-> 1 + m + rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 0, m >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 1, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 1 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   min(z') -{ 104 + 56*m + 16*m*x + 8*m^2 + 56*x + 8*x^2 }-> s14 :|: s14 >= 0, s14 <= 1 + 0 + (1 + m + x), x >= 0, z' = 1 + 0 + (1 + m + x), m >= 0
   min(z') -{ 168 + 72*x + 16*x*x' + 8*x^2 + 72*x' + 8*x'^2 }-> s15 :|: s15 >= 0, s15 <= 1 + (1 + x') + (1 + 0 + x), x' >= 0, x >= 0, z' = 1 + (1 + x') + (1 + 0 + x)
   min(z') -{ 250 + 88*x + 16*x*x'' + 16*x*y' + 8*x^2 + 88*x'' + 16*x''*y' + 8*x''^2 + 89*y' + 8*y'^2 }-> s16 :|: s16 >= 0, s16 <= 1 + (1 + x'') + (1 + (1 + y') + x), s' >= 0, s' <= 1, x >= 0, y' >= 0, z' = 1 + (1 + x'') + (1 + (1 + y') + x), x'' >= 0
   min(z') -{ 0 }-> 0 :|: z' >= 0
   min(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   mins(z', z'', z1) -{ 2 }-> if(1, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0
   mins(z', z'', z1) -{ 2 }-> if(0, 1 + n' + x4, z'', z1) :|: x4 >= 0, z1 >= 0, z' = 1 + n' + x4, z'' >= 0, n' >= 0
   minsort(z') -{ 1 }-> mins(z', 0, 0) :|: z' >= 0
   null(z') -{ 1 }-> 1 :|: z' = 0
   null(z') -{ 1 }-> 0 :|: n >= 0, z' = 1 + n + x, x >= 0
   rm(z', z'') -{ 4 + z' }-> if_rm(s3, 1 + (z' - 1), 1 + (1 + y'') + x) :|: s3 >= 0, s3 <= 1, z'' = 1 + (1 + y'') + x, x >= 0, y'' >= 0, z' - 1 >= 0
   rm(z', z'') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' = 0
   rm(z', z'') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 0, z'' = 1 + (1 + x1) + x
   rm(z', z'') -{ 2 }-> if_rm(0, 1 + (z' - 1), 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' - 1 >= 0
   rm(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' >= 0
   tail(z') -{ 1 }-> x :|: n >= 0, z' = 1 + n + x, x >= 0
   tail(z') -{ 1 }-> 0 :|: z' = 0

Function symbols to be analyzed: {if_rm,rm}, {if2,mins,if}, {minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: O(1) [1], size: O(n^1) [z']
  head: runtime: O(1) [1], size: O(n^1) [z']
  null: runtime: O(1) [1], size: O(1) [1]
  app: runtime: O(n^1) [1 + z'], size: O(n^1) [z' + z'']
  min: runtime: O(n^2) [5 + 4*z' + z'^2], size: O(n^1) [z']
  if_min: runtime: O(n^2) [22 + 24*z'' + 8*z''^2], size: O(n^1) [z'']
  if_rm: runtime: ?, size: O(n^1) [z1]
  rm: runtime: ?, size: O(n^1) [z'']

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

(65) IntTrsBoundProof (UPPER BOUND(ID))

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

Computed RUNTIME bound using KoAT for: rm
after applying outer abstraction to obtain an ITS,
resulting in: O(n^2) with polynomial bound: 79 + 7*z' + 3*z'*z'' + 30*z''

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

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

   app(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0
   app(z', z'') -{ 2 + x }-> 1 + n + s8 :|: s8 >= 0, s8 <= x + z'', n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0
   eq(z', z'') -{ 3 + z' }-> s2 :|: s2 >= 0, s2 <= 1, z' - 1 >= 0, z'' - 1 >= 0
   eq(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' - 1 >= 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   head(z') -{ 1 }-> n :|: n >= 0, z' = 1 + n + x, x >= 0
   head(z') -{ 0 }-> 0 :|: z' >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 110 + 57*m' + 16*m'*n'' + 16*m'*x6 + 8*m'^2 + 57*n'' + 16*n''*x6 + 8*n''^2 + 56*x6 + 8*x6^2 }-> if2(s20, 1 + n'' + (1 + m' + x6), z1, z2) :|: s19 >= 0, s19 <= 1 + n'' + (1 + m' + x6), s20 >= 0, s20 <= 1, s'' >= 0, s'' <= 1, z2 >= 0, z1 >= 0, m' >= 0, x6 >= 0, n'' >= 0, z'' = 1 + n'' + (1 + m' + x6), z' = 0
   if(z', z'', z1, z2) -{ 109 + 57*m'' + 16*m''*n2 + 16*m''*x7 + 8*m''^2 + 56*n2 + 16*n2*x7 + 8*n2^2 + 56*x7 + 8*x7^2 }-> if2(s22, 1 + n2 + (1 + m'' + x7), z1, z2) :|: s21 >= 0, s21 <= 1 + n2 + (1 + m'' + x7), s22 >= 0, s22 <= 1, s1 >= 0, s1 <= 1, z2 >= 0, m'' >= 0, x7 >= 0, z1 >= 0, z'' = 1 + n2 + (1 + m'' + x7), n2 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + z'' }-> if2(s4, 1 + (z'' - 1) + 0, z1, z2) :|: s4 >= 0, s4 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + n'' }-> if2(s5, 1 + n'' + x5, z1, z2) :|: s5 >= 0, s5 <= 1, z'' = 1 + n'' + x5, x5 >= 0, z2 >= 0, z1 >= 0, n'' >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 }-> if2(s6, 1 + (z'' - 1) + 0, z1, z2) :|: s6 >= 0, s6 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 4 }-> if2(s7, z'', z1, z2) :|: s7 >= 0, s7 <= 1, z2 >= 0, z'' >= 0, z1 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 3 }-> mins(x10, 1 + n5 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(x10, 1 + 0 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 4 + z2 }-> mins(app(rm(n3, x8), z1), 0, s10) :|: s10 >= 0, s10 <= z2 + (1 + 0 + 0), z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 5 + z2 }-> mins(app(rm(n3, x8), z1), 0, s9) :|: s9 >= 0, s9 <= z2 + (1 + n3 + 0), z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 4 + z2 }-> mins(app(rm(0, x9), z1), 0, s11) :|: s11 >= 0, s11 <= z2 + (1 + n4 + 0), n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 3 + z2 }-> mins(app(rm(0, x9), z1), 0, s12) :|: s12 >= 0, s12 <= z2 + (1 + 0 + 0), n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 3 + z2 }-> mins(app(rm(0, 0), z1), 0, s13) :|: s13 >= 0, s13 <= z2 + (1 + 0 + 0), z'' = 0, z2 >= 0, z1 >= 0, z' = 1
   if2(z', z'', z1, z2) -{ 2 }-> mins(0, 1 + 0 + z1, z2) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 0
   if_min(z', z'') -{ 11 + 6*n + 2*n*x + n^2 + 6*x + x^2 }-> s17 :|: s17 >= 0, s17 <= 1 + n + x, z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 1, m >= 0
   if_min(z', z'') -{ 11 + 6*m + 2*m*x + m^2 + 6*x + x^2 }-> s18 :|: s18 >= 0, s18 <= 1 + m + x, z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 0, m >= 0
   if_min(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   if_rm(z', z'', z1) -{ 1 }-> rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 1, m >= 0
   if_rm(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   if_rm(z', z'', z1) -{ 1 }-> 1 + m + rm(z'', x) :|: z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 0, m >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 1, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 1 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   min(z') -{ 104 + 56*m + 16*m*x + 8*m^2 + 56*x + 8*x^2 }-> s14 :|: s14 >= 0, s14 <= 1 + 0 + (1 + m + x), x >= 0, z' = 1 + 0 + (1 + m + x), m >= 0
   min(z') -{ 168 + 72*x + 16*x*x' + 8*x^2 + 72*x' + 8*x'^2 }-> s15 :|: s15 >= 0, s15 <= 1 + (1 + x') + (1 + 0 + x), x' >= 0, x >= 0, z' = 1 + (1 + x') + (1 + 0 + x)
   min(z') -{ 250 + 88*x + 16*x*x'' + 16*x*y' + 8*x^2 + 88*x'' + 16*x''*y' + 8*x''^2 + 89*y' + 8*y'^2 }-> s16 :|: s16 >= 0, s16 <= 1 + (1 + x'') + (1 + (1 + y') + x), s' >= 0, s' <= 1, x >= 0, y' >= 0, z' = 1 + (1 + x'') + (1 + (1 + y') + x), x'' >= 0
   min(z') -{ 0 }-> 0 :|: z' >= 0
   min(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   mins(z', z'', z1) -{ 2 }-> if(1, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0
   mins(z', z'', z1) -{ 2 }-> if(0, 1 + n' + x4, z'', z1) :|: x4 >= 0, z1 >= 0, z' = 1 + n' + x4, z'' >= 0, n' >= 0
   minsort(z') -{ 1 }-> mins(z', 0, 0) :|: z' >= 0
   null(z') -{ 1 }-> 1 :|: z' = 0
   null(z') -{ 1 }-> 0 :|: n >= 0, z' = 1 + n + x, x >= 0
   rm(z', z'') -{ 4 + z' }-> if_rm(s3, 1 + (z' - 1), 1 + (1 + y'') + x) :|: s3 >= 0, s3 <= 1, z'' = 1 + (1 + y'') + x, x >= 0, y'' >= 0, z' - 1 >= 0
   rm(z', z'') -{ 2 }-> if_rm(1, 0, 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' = 0
   rm(z', z'') -{ 2 }-> if_rm(0, 0, 1 + (1 + x1) + x) :|: x1 >= 0, x >= 0, z' = 0, z'' = 1 + (1 + x1) + x
   rm(z', z'') -{ 2 }-> if_rm(0, 1 + (z' - 1), 1 + 0 + (z'' - 1)) :|: z'' - 1 >= 0, z' - 1 >= 0
   rm(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' >= 0
   tail(z') -{ 1 }-> x :|: n >= 0, z' = 1 + n + x, x >= 0
   tail(z') -{ 1 }-> 0 :|: z' = 0

Function symbols to be analyzed: {if2,mins,if}, {minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: O(1) [1], size: O(n^1) [z']
  head: runtime: O(1) [1], size: O(n^1) [z']
  null: runtime: O(1) [1], size: O(1) [1]
  app: runtime: O(n^1) [1 + z'], size: O(n^1) [z' + z'']
  min: runtime: O(n^2) [5 + 4*z' + z'^2], size: O(n^1) [z']
  if_min: runtime: O(n^2) [22 + 24*z'' + 8*z''^2], size: O(n^1) [z'']
  if_rm: runtime: O(n^2) [12 + 2*z'' + z''*z1 + 5*z1], size: O(n^1) [z1]
  rm: runtime: O(n^2) [79 + 7*z' + 3*z'*z'' + 30*z''], size: O(n^1) [z'']

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

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

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

   app(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0
   app(z', z'') -{ 2 + x }-> 1 + n + s8 :|: s8 >= 0, s8 <= x + z'', n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0
   eq(z', z'') -{ 3 + z' }-> s2 :|: s2 >= 0, s2 <= 1, z' - 1 >= 0, z'' - 1 >= 0
   eq(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' - 1 >= 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   head(z') -{ 1 }-> n :|: n >= 0, z' = 1 + n + x, x >= 0
   head(z') -{ 0 }-> 0 :|: z' >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 110 + 57*m' + 16*m'*n'' + 16*m'*x6 + 8*m'^2 + 57*n'' + 16*n''*x6 + 8*n''^2 + 56*x6 + 8*x6^2 }-> if2(s20, 1 + n'' + (1 + m' + x6), z1, z2) :|: s19 >= 0, s19 <= 1 + n'' + (1 + m' + x6), s20 >= 0, s20 <= 1, s'' >= 0, s'' <= 1, z2 >= 0, z1 >= 0, m' >= 0, x6 >= 0, n'' >= 0, z'' = 1 + n'' + (1 + m' + x6), z' = 0
   if(z', z'', z1, z2) -{ 109 + 57*m'' + 16*m''*n2 + 16*m''*x7 + 8*m''^2 + 56*n2 + 16*n2*x7 + 8*n2^2 + 56*x7 + 8*x7^2 }-> if2(s22, 1 + n2 + (1 + m'' + x7), z1, z2) :|: s21 >= 0, s21 <= 1 + n2 + (1 + m'' + x7), s22 >= 0, s22 <= 1, s1 >= 0, s1 <= 1, z2 >= 0, m'' >= 0, x7 >= 0, z1 >= 0, z'' = 1 + n2 + (1 + m'' + x7), n2 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + z'' }-> if2(s4, 1 + (z'' - 1) + 0, z1, z2) :|: s4 >= 0, s4 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + n'' }-> if2(s5, 1 + n'' + x5, z1, z2) :|: s5 >= 0, s5 <= 1, z'' = 1 + n'' + x5, x5 >= 0, z2 >= 0, z1 >= 0, n'' >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 }-> if2(s6, 1 + (z'' - 1) + 0, z1, z2) :|: s6 >= 0, s6 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 4 }-> if2(s7, z'', z1, z2) :|: s7 >= 0, s7 <= 1, z2 >= 0, z'' >= 0, z1 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 85 + 7*n3 + 3*n3*x8 + s29 + 30*x8 + z2 }-> mins(s30, 0, s9) :|: s29 >= 0, s29 <= x8, s30 >= 0, s30 <= s29 + z1, s9 >= 0, s9 <= z2 + (1 + n3 + 0), z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 84 + 7*n3 + 3*n3*x8 + s31 + 30*x8 + z2 }-> mins(s32, 0, s10) :|: s31 >= 0, s31 <= x8, s32 >= 0, s32 <= s31 + z1, s10 >= 0, s10 <= z2 + (1 + 0 + 0), z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 84 + s33 + 30*x9 + z2 }-> mins(s34, 0, s11) :|: s33 >= 0, s33 <= x9, s34 >= 0, s34 <= s33 + z1, s11 >= 0, s11 <= z2 + (1 + n4 + 0), n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 83 + s35 + 30*x9 + z2 }-> mins(s36, 0, s12) :|: s35 >= 0, s35 <= x9, s36 >= 0, s36 <= s35 + z1, s12 >= 0, s12 <= z2 + (1 + 0 + 0), n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 83 + s37 + z2 }-> mins(s38, 0, s13) :|: s37 >= 0, s37 <= 0, s38 >= 0, s38 <= s37 + z1, s13 >= 0, s13 <= z2 + (1 + 0 + 0), z'' = 0, z2 >= 0, z1 >= 0, z' = 1
   if2(z', z'', z1, z2) -{ 3 }-> mins(x10, 1 + n5 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(x10, 1 + 0 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(0, 1 + 0 + z1, z2) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 0
   if_min(z', z'') -{ 11 + 6*n + 2*n*x + n^2 + 6*x + x^2 }-> s17 :|: s17 >= 0, s17 <= 1 + n + x, z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 1, m >= 0
   if_min(z', z'') -{ 11 + 6*m + 2*m*x + m^2 + 6*x + x^2 }-> s18 :|: s18 >= 0, s18 <= 1 + m + x, z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 0, m >= 0
   if_min(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   if_rm(z', z'', z1) -{ 80 + 30*x + 3*x*z'' + 7*z'' }-> s27 :|: s27 >= 0, s27 <= x, z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 1, m >= 0
   if_rm(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   if_rm(z', z'', z1) -{ 80 + 30*x + 3*x*z'' + 7*z'' }-> 1 + m + s28 :|: s28 >= 0, s28 <= x, z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 0, m >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 1, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 1 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   min(z') -{ 104 + 56*m + 16*m*x + 8*m^2 + 56*x + 8*x^2 }-> s14 :|: s14 >= 0, s14 <= 1 + 0 + (1 + m + x), x >= 0, z' = 1 + 0 + (1 + m + x), m >= 0
   min(z') -{ 168 + 72*x + 16*x*x' + 8*x^2 + 72*x' + 8*x'^2 }-> s15 :|: s15 >= 0, s15 <= 1 + (1 + x') + (1 + 0 + x), x' >= 0, x >= 0, z' = 1 + (1 + x') + (1 + 0 + x)
   min(z') -{ 250 + 88*x + 16*x*x'' + 16*x*y' + 8*x^2 + 88*x'' + 16*x''*y' + 8*x''^2 + 89*y' + 8*y'^2 }-> s16 :|: s16 >= 0, s16 <= 1 + (1 + x'') + (1 + (1 + y') + x), s' >= 0, s' <= 1, x >= 0, y' >= 0, z' = 1 + (1 + x'') + (1 + (1 + y') + x), x'' >= 0
   min(z') -{ 0 }-> 0 :|: z' >= 0
   min(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   mins(z', z'', z1) -{ 2 }-> if(1, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0
   mins(z', z'', z1) -{ 2 }-> if(0, 1 + n' + x4, z'', z1) :|: x4 >= 0, z1 >= 0, z' = 1 + n' + x4, z'' >= 0, n' >= 0
   minsort(z') -{ 1 }-> mins(z', 0, 0) :|: z' >= 0
   null(z') -{ 1 }-> 1 :|: z' = 0
   null(z') -{ 1 }-> 0 :|: n >= 0, z' = 1 + n + x, x >= 0
   rm(z', z'') -{ 14 + 5*z'' }-> s23 :|: s23 >= 0, s23 <= 1 + 0 + (z'' - 1), z'' - 1 >= 0, z' = 0
   rm(z', z'') -{ 24 + 5*x + 5*x1 }-> s24 :|: s24 >= 0, s24 <= 1 + (1 + x1) + x, x1 >= 0, x >= 0, z' = 0, z'' = 1 + (1 + x1) + x
   rm(z', z'') -{ 14 + 2*z' + z'*z'' + 5*z'' }-> s25 :|: s25 >= 0, s25 <= 1 + 0 + (z'' - 1), z'' - 1 >= 0, z' - 1 >= 0
   rm(z', z'') -{ 26 + 5*x + x*z' + 5*y'' + y''*z' + 5*z' }-> s26 :|: s26 >= 0, s26 <= 1 + (1 + y'') + x, s3 >= 0, s3 <= 1, z'' = 1 + (1 + y'') + x, x >= 0, y'' >= 0, z' - 1 >= 0
   rm(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' >= 0
   tail(z') -{ 1 }-> x :|: n >= 0, z' = 1 + n + x, x >= 0
   tail(z') -{ 1 }-> 0 :|: z' = 0

Function symbols to be analyzed: {if2,mins,if}, {minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: O(1) [1], size: O(n^1) [z']
  head: runtime: O(1) [1], size: O(n^1) [z']
  null: runtime: O(1) [1], size: O(1) [1]
  app: runtime: O(n^1) [1 + z'], size: O(n^1) [z' + z'']
  min: runtime: O(n^2) [5 + 4*z' + z'^2], size: O(n^1) [z']
  if_min: runtime: O(n^2) [22 + 24*z'' + 8*z''^2], size: O(n^1) [z'']
  if_rm: runtime: O(n^2) [12 + 2*z'' + z''*z1 + 5*z1], size: O(n^1) [z1]
  rm: runtime: O(n^2) [79 + 7*z' + 3*z'*z'' + 30*z''], size: O(n^1) [z'']

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

(69) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

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

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

   app(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0
   app(z', z'') -{ 2 + x }-> 1 + n + s8 :|: s8 >= 0, s8 <= x + z'', n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0
   eq(z', z'') -{ 3 + z' }-> s2 :|: s2 >= 0, s2 <= 1, z' - 1 >= 0, z'' - 1 >= 0
   eq(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' - 1 >= 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   head(z') -{ 1 }-> n :|: n >= 0, z' = 1 + n + x, x >= 0
   head(z') -{ 0 }-> 0 :|: z' >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 110 + 57*m' + 16*m'*n'' + 16*m'*x6 + 8*m'^2 + 57*n'' + 16*n''*x6 + 8*n''^2 + 56*x6 + 8*x6^2 }-> if2(s20, 1 + n'' + (1 + m' + x6), z1, z2) :|: s19 >= 0, s19 <= 1 + n'' + (1 + m' + x6), s20 >= 0, s20 <= 1, s'' >= 0, s'' <= 1, z2 >= 0, z1 >= 0, m' >= 0, x6 >= 0, n'' >= 0, z'' = 1 + n'' + (1 + m' + x6), z' = 0
   if(z', z'', z1, z2) -{ 109 + 57*m'' + 16*m''*n2 + 16*m''*x7 + 8*m''^2 + 56*n2 + 16*n2*x7 + 8*n2^2 + 56*x7 + 8*x7^2 }-> if2(s22, 1 + n2 + (1 + m'' + x7), z1, z2) :|: s21 >= 0, s21 <= 1 + n2 + (1 + m'' + x7), s22 >= 0, s22 <= 1, s1 >= 0, s1 <= 1, z2 >= 0, m'' >= 0, x7 >= 0, z1 >= 0, z'' = 1 + n2 + (1 + m'' + x7), n2 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + z'' }-> if2(s4, 1 + (z'' - 1) + 0, z1, z2) :|: s4 >= 0, s4 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + n'' }-> if2(s5, 1 + n'' + x5, z1, z2) :|: s5 >= 0, s5 <= 1, z'' = 1 + n'' + x5, x5 >= 0, z2 >= 0, z1 >= 0, n'' >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 }-> if2(s6, 1 + (z'' - 1) + 0, z1, z2) :|: s6 >= 0, s6 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 4 }-> if2(s7, z'', z1, z2) :|: s7 >= 0, s7 <= 1, z2 >= 0, z'' >= 0, z1 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 85 + 7*n3 + 3*n3*x8 + s29 + 30*x8 + z2 }-> mins(s30, 0, s9) :|: s29 >= 0, s29 <= x8, s30 >= 0, s30 <= s29 + z1, s9 >= 0, s9 <= z2 + (1 + n3 + 0), z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 84 + 7*n3 + 3*n3*x8 + s31 + 30*x8 + z2 }-> mins(s32, 0, s10) :|: s31 >= 0, s31 <= x8, s32 >= 0, s32 <= s31 + z1, s10 >= 0, s10 <= z2 + (1 + 0 + 0), z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 84 + s33 + 30*x9 + z2 }-> mins(s34, 0, s11) :|: s33 >= 0, s33 <= x9, s34 >= 0, s34 <= s33 + z1, s11 >= 0, s11 <= z2 + (1 + n4 + 0), n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 83 + s35 + 30*x9 + z2 }-> mins(s36, 0, s12) :|: s35 >= 0, s35 <= x9, s36 >= 0, s36 <= s35 + z1, s12 >= 0, s12 <= z2 + (1 + 0 + 0), n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 83 + s37 + z2 }-> mins(s38, 0, s13) :|: s37 >= 0, s37 <= 0, s38 >= 0, s38 <= s37 + z1, s13 >= 0, s13 <= z2 + (1 + 0 + 0), z'' = 0, z2 >= 0, z1 >= 0, z' = 1
   if2(z', z'', z1, z2) -{ 3 }-> mins(x10, 1 + n5 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(x10, 1 + 0 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(0, 1 + 0 + z1, z2) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 0
   if_min(z', z'') -{ 11 + 6*n + 2*n*x + n^2 + 6*x + x^2 }-> s17 :|: s17 >= 0, s17 <= 1 + n + x, z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 1, m >= 0
   if_min(z', z'') -{ 11 + 6*m + 2*m*x + m^2 + 6*x + x^2 }-> s18 :|: s18 >= 0, s18 <= 1 + m + x, z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 0, m >= 0
   if_min(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   if_rm(z', z'', z1) -{ 80 + 30*x + 3*x*z'' + 7*z'' }-> s27 :|: s27 >= 0, s27 <= x, z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 1, m >= 0
   if_rm(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   if_rm(z', z'', z1) -{ 80 + 30*x + 3*x*z'' + 7*z'' }-> 1 + m + s28 :|: s28 >= 0, s28 <= x, z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 0, m >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 1, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 1 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   min(z') -{ 104 + 56*m + 16*m*x + 8*m^2 + 56*x + 8*x^2 }-> s14 :|: s14 >= 0, s14 <= 1 + 0 + (1 + m + x), x >= 0, z' = 1 + 0 + (1 + m + x), m >= 0
   min(z') -{ 168 + 72*x + 16*x*x' + 8*x^2 + 72*x' + 8*x'^2 }-> s15 :|: s15 >= 0, s15 <= 1 + (1 + x') + (1 + 0 + x), x' >= 0, x >= 0, z' = 1 + (1 + x') + (1 + 0 + x)
   min(z') -{ 250 + 88*x + 16*x*x'' + 16*x*y' + 8*x^2 + 88*x'' + 16*x''*y' + 8*x''^2 + 89*y' + 8*y'^2 }-> s16 :|: s16 >= 0, s16 <= 1 + (1 + x'') + (1 + (1 + y') + x), s' >= 0, s' <= 1, x >= 0, y' >= 0, z' = 1 + (1 + x'') + (1 + (1 + y') + x), x'' >= 0
   min(z') -{ 0 }-> 0 :|: z' >= 0
   min(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   mins(z', z'', z1) -{ 2 }-> if(1, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0
   mins(z', z'', z1) -{ 2 }-> if(0, 1 + n' + x4, z'', z1) :|: x4 >= 0, z1 >= 0, z' = 1 + n' + x4, z'' >= 0, n' >= 0
   minsort(z') -{ 1 }-> mins(z', 0, 0) :|: z' >= 0
   null(z') -{ 1 }-> 1 :|: z' = 0
   null(z') -{ 1 }-> 0 :|: n >= 0, z' = 1 + n + x, x >= 0
   rm(z', z'') -{ 14 + 5*z'' }-> s23 :|: s23 >= 0, s23 <= 1 + 0 + (z'' - 1), z'' - 1 >= 0, z' = 0
   rm(z', z'') -{ 24 + 5*x + 5*x1 }-> s24 :|: s24 >= 0, s24 <= 1 + (1 + x1) + x, x1 >= 0, x >= 0, z' = 0, z'' = 1 + (1 + x1) + x
   rm(z', z'') -{ 14 + 2*z' + z'*z'' + 5*z'' }-> s25 :|: s25 >= 0, s25 <= 1 + 0 + (z'' - 1), z'' - 1 >= 0, z' - 1 >= 0
   rm(z', z'') -{ 26 + 5*x + x*z' + 5*y'' + y''*z' + 5*z' }-> s26 :|: s26 >= 0, s26 <= 1 + (1 + y'') + x, s3 >= 0, s3 <= 1, z'' = 1 + (1 + y'') + x, x >= 0, y'' >= 0, z' - 1 >= 0
   rm(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' >= 0
   tail(z') -{ 1 }-> x :|: n >= 0, z' = 1 + n + x, x >= 0
   tail(z') -{ 1 }-> 0 :|: z' = 0

Function symbols to be analyzed: {if2,mins,if}, {minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: O(1) [1], size: O(n^1) [z']
  head: runtime: O(1) [1], size: O(n^1) [z']
  null: runtime: O(1) [1], size: O(1) [1]
  app: runtime: O(n^1) [1 + z'], size: O(n^1) [z' + z'']
  min: runtime: O(n^2) [5 + 4*z' + z'^2], size: O(n^1) [z']
  if_min: runtime: O(n^2) [22 + 24*z'' + 8*z''^2], size: O(n^1) [z'']
  if_rm: runtime: O(n^2) [12 + 2*z'' + z''*z1 + 5*z1], size: O(n^1) [z1]
  rm: runtime: O(n^2) [79 + 7*z' + 3*z'*z'' + 30*z''], size: O(n^1) [z'']
  if2: runtime: ?, size: O(n^1) [1 + z'' + z1 + z2]
  mins: runtime: ?, size: O(n^1) [1 + z' + z'' + z1]
  if: runtime: ?, size: O(n^1) [1 + z'' + z1 + z2]

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

(71) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   app(z', z'') -{ 1 }-> z'' :|: z'' >= 0, z' = 0
   app(z', z'') -{ 2 + x }-> 1 + n + s8 :|: s8 >= 0, s8 <= x + z'', n >= 0, z' = 1 + n + x, x >= 0, z'' >= 0
   eq(z', z'') -{ 3 + z' }-> s2 :|: s2 >= 0, s2 <= 1, z' - 1 >= 0, z'' - 1 >= 0
   eq(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' - 1 >= 0, z' = 0
   eq(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   head(z') -{ 1 }-> n :|: n >= 0, z' = 1 + n + x, x >= 0
   head(z') -{ 0 }-> 0 :|: z' >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 110 + 57*m' + 16*m'*n'' + 16*m'*x6 + 8*m'^2 + 57*n'' + 16*n''*x6 + 8*n''^2 + 56*x6 + 8*x6^2 }-> if2(s20, 1 + n'' + (1 + m' + x6), z1, z2) :|: s19 >= 0, s19 <= 1 + n'' + (1 + m' + x6), s20 >= 0, s20 <= 1, s'' >= 0, s'' <= 1, z2 >= 0, z1 >= 0, m' >= 0, x6 >= 0, n'' >= 0, z'' = 1 + n'' + (1 + m' + x6), z' = 0
   if(z', z'', z1, z2) -{ 109 + 57*m'' + 16*m''*n2 + 16*m''*x7 + 8*m''^2 + 56*n2 + 16*n2*x7 + 8*n2^2 + 56*x7 + 8*x7^2 }-> if2(s22, 1 + n2 + (1 + m'' + x7), z1, z2) :|: s21 >= 0, s21 <= 1 + n2 + (1 + m'' + x7), s22 >= 0, s22 <= 1, s1 >= 0, s1 <= 1, z2 >= 0, m'' >= 0, x7 >= 0, z1 >= 0, z'' = 1 + n2 + (1 + m'' + x7), n2 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + z'' }-> if2(s4, 1 + (z'' - 1) + 0, z1, z2) :|: s4 >= 0, s4 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 + n'' }-> if2(s5, 1 + n'' + x5, z1, z2) :|: s5 >= 0, s5 <= 1, z'' = 1 + n'' + x5, x5 >= 0, z2 >= 0, z1 >= 0, n'' >= 0, z' = 0
   if(z', z'', z1, z2) -{ 5 }-> if2(s6, 1 + (z'' - 1) + 0, z1, z2) :|: s6 >= 0, s6 <= 1, z2 >= 0, z1 >= 0, z'' - 1 >= 0, z' = 0
   if(z', z'', z1, z2) -{ 4 }-> if2(s7, z'', z1, z2) :|: s7 >= 0, s7 <= 1, z2 >= 0, z'' >= 0, z1 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 85 + 7*n3 + 3*n3*x8 + s29 + 30*x8 + z2 }-> mins(s30, 0, s9) :|: s29 >= 0, s29 <= x8, s30 >= 0, s30 <= s29 + z1, s9 >= 0, s9 <= z2 + (1 + n3 + 0), z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 84 + 7*n3 + 3*n3*x8 + s31 + 30*x8 + z2 }-> mins(s32, 0, s10) :|: s31 >= 0, s31 <= x8, s32 >= 0, s32 <= s31 + z1, s10 >= 0, s10 <= z2 + (1 + 0 + 0), z2 >= 0, x8 >= 0, z1 >= 0, z'' = 1 + n3 + x8, z' = 1, n3 >= 0
   if2(z', z'', z1, z2) -{ 84 + s33 + 30*x9 + z2 }-> mins(s34, 0, s11) :|: s33 >= 0, s33 <= x9, s34 >= 0, s34 <= s33 + z1, s11 >= 0, s11 <= z2 + (1 + n4 + 0), n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 83 + s35 + 30*x9 + z2 }-> mins(s36, 0, s12) :|: s35 >= 0, s35 <= x9, s36 >= 0, s36 <= s35 + z1, s12 >= 0, s12 <= z2 + (1 + 0 + 0), n4 >= 0, z2 >= 0, z1 >= 0, z'' = 1 + n4 + x9, z' = 1, x9 >= 0
   if2(z', z'', z1, z2) -{ 83 + s37 + z2 }-> mins(s38, 0, s13) :|: s37 >= 0, s37 <= 0, s38 >= 0, s38 <= s37 + z1, s13 >= 0, s13 <= z2 + (1 + 0 + 0), z'' = 0, z2 >= 0, z1 >= 0, z' = 1
   if2(z', z'', z1, z2) -{ 3 }-> mins(x10, 1 + n5 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(x10, 1 + 0 + z1, z2) :|: z2 >= 0, z1 >= 0, z'' = 1 + n5 + x10, n5 >= 0, x10 >= 0, z' = 0
   if2(z', z'', z1, z2) -{ 2 }-> mins(0, 1 + 0 + z1, z2) :|: z'' = 0, z2 >= 0, z1 >= 0, z' = 0
   if_min(z', z'') -{ 11 + 6*n + 2*n*x + n^2 + 6*x + x^2 }-> s17 :|: s17 >= 0, s17 <= 1 + n + x, z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 1, m >= 0
   if_min(z', z'') -{ 11 + 6*m + 2*m*x + m^2 + 6*x + x^2 }-> s18 :|: s18 >= 0, s18 <= 1 + m + x, z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 0, m >= 0
   if_min(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   if_rm(z', z'', z1) -{ 80 + 30*x + 3*x*z'' + 7*z'' }-> s27 :|: s27 >= 0, s27 <= x, z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 1, m >= 0
   if_rm(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   if_rm(z', z'', z1) -{ 80 + 30*x + 3*x*z'' + 7*z'' }-> 1 + m + s28 :|: s28 >= 0, s28 <= x, z'' >= 0, x >= 0, z1 = 1 + m + x, z' = 0, m >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 1, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 1 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' - 1 >= 0
   min(z') -{ 104 + 56*m + 16*m*x + 8*m^2 + 56*x + 8*x^2 }-> s14 :|: s14 >= 0, s14 <= 1 + 0 + (1 + m + x), x >= 0, z' = 1 + 0 + (1 + m + x), m >= 0
   min(z') -{ 168 + 72*x + 16*x*x' + 8*x^2 + 72*x' + 8*x'^2 }-> s15 :|: s15 >= 0, s15 <= 1 + (1 + x') + (1 + 0 + x), x' >= 0, x >= 0, z' = 1 + (1 + x') + (1 + 0 + x)
   min(z') -{ 250 + 88*x + 16*x*x'' + 16*x*y' + 8*x^2 + 88*x'' + 16*x''*y' + 8*x''^2 + 89*y' + 8*y'^2 }-> s16 :|: s16 >= 0, s16 <= 1 + (1 + x'') + (1 + (1 + y') + x), s' >= 0, s' <= 1, x >= 0, y' >= 0, z' = 1 + (1 + x'') + (1 + (1 + y') + x), x'' >= 0
   min(z') -{ 0 }-> 0 :|: z' >= 0
   min(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   mins(z', z'', z1) -{ 2 }-> if(1, 0, z'', z1) :|: z1 >= 0, z'' >= 0, z' = 0
   mins(z', z'', z1) -{ 2 }-> if(0, 1 + n' + x4, z'', z1) :|: x4 >= 0, z1 >= 0, z' = 1 + n' + x4, z'' >= 0, n' >= 0
   minsort(z') -{ 1 }-> mins(z', 0, 0) :|: z' >= 0
   null(z') -{ 1 }-> 1 :|: z' = 0
   null(z') -{ 1 }-> 0 :|: n >= 0, z' = 1 + n + x, x >= 0
   rm(z', z'') -{ 14 + 5*z'' }-> s23 :|: s23 >= 0, s23 <= 1 + 0 + (z'' - 1), z'' - 1 >= 0, z' = 0
   rm(z', z'') -{ 24 + 5*x + 5*x1 }-> s24 :|: s24 >= 0, s24 <= 1 + (1 + x1) + x, x1 >= 0, x >= 0, z' = 0, z'' = 1 + (1 + x1) + x
   rm(z', z'') -{ 14 + 2*z' + z'*z'' + 5*z'' }-> s25 :|: s25 >= 0, s25 <= 1 + 0 + (z'' - 1), z'' - 1 >= 0, z' - 1 >= 0
   rm(z', z'') -{ 26 + 5*x + x*z' + 5*y'' + y''*z' + 5*z' }-> s26 :|: s26 >= 0, s26 <= 1 + (1 + y'') + x, s3 >= 0, s3 <= 1, z'' = 1 + (1 + y'') + x, x >= 0, y'' >= 0, z' - 1 >= 0
   rm(z', z'') -{ 1 }-> 0 :|: z'' = 0, z' >= 0
   tail(z') -{ 1 }-> x :|: n >= 0, z' = 1 + n + x, x >= 0
   tail(z') -{ 1 }-> 0 :|: z' = 0

Function symbols to be analyzed: {if2,mins,if}, {minsort}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [1]
  eq: runtime: O(n^1) [3 + z'], size: O(1) [1]
  tail: runtime: O(1) [1], size: O(n^1) [z']
  head: runtime: O(1) [1], size: O(n^1) [z']
  null: runtime: O(1) [1], size: O(1) [1]
  app: runtime: O(n^1) [1 + z'], size: O(n^1) [z' + z'']
  min: runtime: O(n^2) [5 + 4*z' + z'^2], size: O(n^1) [z']
  if_min: runtime: O(n^2) [22 + 24*z'' + 8*z''^2], size: O(n^1) [z'']
  if_rm: runtime: O(n^2) [12 + 2*z'' + z''*z1 + 5*z1], size: O(n^1) [z1]
  rm: runtime: O(n^2) [79 + 7*z' + 3*z'*z'' + 30*z''], size: O(n^1) [z'']
  if2: runtime: INF, size: O(n^1) [1 + z'' + z1 + z2]
  mins: runtime: ?, size: O(n^1) [1 + z' + z'' + z1]
  if: runtime: ?, size: O(n^1) [1 + z'' + z1 + z2]

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

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

   min(v0) -> null_min [0]
   if_min(v0, v1) -> null_if_min [0]
   head(v0) -> null_head [0]
   if_rm(v0, v1, v2) -> null_if_rm [0]
   eq(v0, v1) -> null_eq [0]
   le(v0, v1) -> null_le [0]
   app(v0, v1) -> null_app [0]
   tail(v0) -> null_tail [0]
   null(v0) -> null_null [0]
   rm(v0, v1) -> null_rm [0]
   if(v0, v1, v2, v3) -> null_if [0]
   if2(v0, v1, v2, v3) -> null_if2 [0]

And the following fresh constants:    null_min, null_if_min, null_head, null_if_rm, null_eq, null_le, null_app, null_tail, null_null, null_rm, null_if, null_if2

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

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

   eq(0, 0) -> true [1]
   eq(0, s(x)) -> false [1]
   eq(s(x), 0) -> false [1]
   eq(s(x), s(y)) -> eq(x, y) [1]
   le(0, y) -> true [1]
   le(s(x), 0) -> false [1]
   le(s(x), s(y)) -> le(x, y) [1]
   app(nil, y) -> y [1]
   app(add(n, x), y) -> add(n, app(x, y)) [1]
   min(add(n, nil)) -> n [1]
   min(add(n, add(m, x))) -> if_min(le(n, m), add(n, add(m, x))) [1]
   if_min(true, add(n, add(m, x))) -> min(add(n, x)) [1]
   if_min(false, add(n, add(m, x))) -> min(add(m, x)) [1]
   head(add(n, x)) -> n [1]
   tail(add(n, x)) -> x [1]
   tail(nil) -> nil [1]
   null(nil) -> true [1]
   null(add(n, x)) -> false [1]
   rm(n, nil) -> nil [1]
   rm(n, add(m, x)) -> if_rm(eq(n, m), n, add(m, x)) [1]
   if_rm(true, n, add(m, x)) -> rm(n, x) [1]
   if_rm(false, n, add(m, x)) -> add(m, rm(n, x)) [1]
   minsort(x) -> mins(x, nil, nil) [1]
   mins(x, y, z) -> if(null(x), x, y, z) [1]
   if(true, x, y, z) -> z [1]
   if(false, x, y, z) -> if2(eq(head(x), min(x)), x, y, z) [1]
   if2(true, x, y, z) -> mins(app(rm(head(x), tail(x)), y), nil, app(z, add(head(x), nil))) [1]
   if2(false, x, y, z) -> mins(tail(x), add(head(x), y), z) [1]
   min(v0) -> null_min [0]
   if_min(v0, v1) -> null_if_min [0]
   head(v0) -> null_head [0]
   if_rm(v0, v1, v2) -> null_if_rm [0]
   eq(v0, v1) -> null_eq [0]
   le(v0, v1) -> null_le [0]
   app(v0, v1) -> null_app [0]
   tail(v0) -> null_tail [0]
   null(v0) -> null_null [0]
   rm(v0, v1) -> null_rm [0]
   if(v0, v1, v2, v3) -> null_if [0]
   if2(v0, v1, v2, v3) -> null_if2 [0]

The TRS has the following type information:
eq :: 0:s:null_min:null_if_min:null_head -> 0:s:null_min:null_if_min:null_head -> true:false:null_eq:null_le:null_null
0 :: 0:s:null_min:null_if_min:null_head
true :: true:false:null_eq:null_le:null_null
s :: 0:s:null_min:null_if_min:null_head -> 0:s:null_min:null_if_min:null_head
false :: true:false:null_eq:null_le:null_null
le :: 0:s:null_min:null_if_min:null_head -> 0:s:null_min:null_if_min:null_head -> true:false:null_eq:null_le:null_null
app :: nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2 -> nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2 -> nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2
nil :: nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2
add :: 0:s:null_min:null_if_min:null_head -> nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2 -> nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2
min :: nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2 -> 0:s:null_min:null_if_min:null_head
if_min :: true:false:null_eq:null_le:null_null -> nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2 -> 0:s:null_min:null_if_min:null_head
head :: nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2 -> 0:s:null_min:null_if_min:null_head
tail :: nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2 -> nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2
null :: nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2 -> true:false:null_eq:null_le:null_null
rm :: 0:s:null_min:null_if_min:null_head -> nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2 -> nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2
if_rm :: true:false:null_eq:null_le:null_null -> 0:s:null_min:null_if_min:null_head -> nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2 -> nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2
minsort :: nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2 -> nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2
mins :: nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2 -> nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2 -> nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2 -> nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2
if :: true:false:null_eq:null_le:null_null -> nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2 -> nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2 -> nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2 -> nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2
if2 :: true:false:null_eq:null_le:null_null -> nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2 -> nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2 -> nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2 -> nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2
null_min :: 0:s:null_min:null_if_min:null_head
null_if_min :: 0:s:null_min:null_if_min:null_head
null_head :: 0:s:null_min:null_if_min:null_head
null_if_rm :: nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2
null_eq :: true:false:null_eq:null_le:null_null
null_le :: true:false:null_eq:null_le:null_null
null_app :: nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2
null_tail :: nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2
null_null :: true:false:null_eq:null_le:null_null
null_rm :: nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2
null_if :: nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2
null_if2 :: nil:add:null_if_rm:null_app:null_tail:null_rm:null_if:null_if2

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

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

   0 => 0
   true => 2
   false => 1
   nil => 0
   null_min => 0
   null_if_min => 0
   null_head => 0
   null_if_rm => 0
   null_eq => 0
   null_le => 0
   null_app => 0
   null_tail => 0
   null_null => 0
   null_rm => 0
   null_if => 0
   null_if2 => 0

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

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

   app(z', z'') -{ 1 }-> y :|: z'' = y, y >= 0, z' = 0
   app(z', z'') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z'' = v1, z' = v0
   app(z', z'') -{ 1 }-> 1 + n + app(x, y) :|: n >= 0, z'' = y, z' = 1 + n + x, x >= 0, y >= 0
   eq(z', z'') -{ 1 }-> eq(x, y) :|: z' = 1 + x, x >= 0, y >= 0, z'' = 1 + y
   eq(z', z'') -{ 1 }-> 2 :|: z'' = 0, z' = 0
   eq(z', z'') -{ 1 }-> 1 :|: x >= 0, z'' = 1 + x, z' = 0
   eq(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 1 + x, x >= 0
   eq(z', z'') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z'' = v1, z' = v0
   head(z') -{ 1 }-> n :|: n >= 0, z' = 1 + n + x, x >= 0
   head(z') -{ 0 }-> 0 :|: v0 >= 0, z' = v0
   if(z', z'', z1, z2) -{ 1 }-> z :|: z1 = y, z >= 0, z' = 2, z2 = z, x >= 0, y >= 0, z'' = x
   if(z', z'', z1, z2) -{ 1 }-> if2(eq(head(x), min(x)), x, y, z) :|: z1 = y, z >= 0, z2 = z, x >= 0, y >= 0, z'' = x, z' = 1
   if(z', z'', z1, z2) -{ 0 }-> 0 :|: z2 = v3, v0 >= 0, z1 = v2, v1 >= 0, z'' = v1, v2 >= 0, v3 >= 0, z' = v0
   if2(z', z'', z1, z2) -{ 1 }-> mins(tail(x), 1 + head(x) + y, z) :|: z1 = y, z >= 0, z2 = z, x >= 0, y >= 0, z'' = x, z' = 1
   if2(z', z'', z1, z2) -{ 1 }-> mins(app(rm(head(x), tail(x)), y), 0, app(z, 1 + head(x) + 0)) :|: z1 = y, z >= 0, z' = 2, z2 = z, x >= 0, y >= 0, z'' = x
   if2(z', z'', z1, z2) -{ 0 }-> 0 :|: z2 = v3, v0 >= 0, z1 = v2, v1 >= 0, z'' = v1, v2 >= 0, v3 >= 0, z' = v0
   if_min(z', z'') -{ 1 }-> min(1 + m + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, x >= 0, z' = 1, m >= 0
   if_min(z', z'') -{ 1 }-> min(1 + n + x) :|: z'' = 1 + n + (1 + m + x), n >= 0, z' = 2, x >= 0, m >= 0
   if_min(z', z'') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z'' = v1, z' = v0
   if_rm(z', z'', z1) -{ 1 }-> rm(n, x) :|: n >= 0, z'' = n, z' = 2, x >= 0, z1 = 1 + m + x, m >= 0
   if_rm(z', z'', z1) -{ 0 }-> 0 :|: v0 >= 0, z1 = v2, v1 >= 0, z'' = v1, v2 >= 0, z' = v0
   if_rm(z', z'', z1) -{ 1 }-> 1 + m + rm(n, x) :|: n >= 0, z'' = n, x >= 0, z1 = 1 + m + x, z' = 1, m >= 0
   le(z', z'') -{ 1 }-> le(x, y) :|: z' = 1 + x, x >= 0, y >= 0, z'' = 1 + y
   le(z', z'') -{ 1 }-> 2 :|: z'' = y, y >= 0, z' = 0
   le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' = 1 + x, x >= 0
   le(z', z'') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z'' = v1, z' = v0
   min(z') -{ 1 }-> n :|: n >= 0, z' = 1 + n + 0
   min(z') -{ 1 }-> if_min(le(n, m), 1 + n + (1 + m + x)) :|: n >= 0, x >= 0, z' = 1 + n + (1 + m + x), m >= 0
   min(z') -{ 0 }-> 0 :|: v0 >= 0, z' = v0
   mins(z', z'', z1) -{ 1 }-> if(null(x), x, y, z) :|: z1 = z, z >= 0, z' = x, z'' = y, x >= 0, y >= 0
   minsort(z') -{ 1 }-> mins(x, 0, 0) :|: z' = x, x >= 0
   null(z') -{ 1 }-> 2 :|: z' = 0
   null(z') -{ 1 }-> 1 :|: n >= 0, z' = 1 + n + x, x >= 0
   null(z') -{ 0 }-> 0 :|: v0 >= 0, z' = v0
   rm(z', z'') -{ 1 }-> if_rm(eq(n, m), n, 1 + m + x) :|: n >= 0, z'' = 1 + m + x, x >= 0, z' = n, m >= 0
   rm(z', z'') -{ 1 }-> 0 :|: z'' = 0, n >= 0, z' = n
   rm(z', z'') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z'' = v1, z' = v0
   tail(z') -{ 1 }-> x :|: n >= 0, z' = 1 + n + x, x >= 0
   tail(z') -{ 1 }-> 0 :|: z' = 0
   tail(z') -{ 0 }-> 0 :|: v0 >= 0, z' = v0

Only complete derivations are relevant for the runtime complexity.

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

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

(78)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   head(add(z0, z1)) -> z0
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   null(nil) -> true
   null(add(z0, z1)) -> false
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   minsort(z0) -> mins(z0, nil, nil)
   mins(z0, z1, z2) -> if(null(z0), z0, z1, z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> if2(eq(head(z0), min(z0)), z0, z1, z2)
   if2(true, z0, z1, z2) -> mins(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil)))
   if2(false, z0, z1, z2) -> mins(tail(z0), add(head(z0), z1), z2)
Tuples:
   EQ(0, 0) -> c
   EQ(0, s(z0)) -> c1
   EQ(s(z0), 0) -> c2
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(0, z0) -> c4
   LE(s(z0), 0) -> c5
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(nil, z0) -> c7
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, nil)) -> c9
   MIN(add(z0, add(z1, z2))) -> c10(IF_MIN(le(z0, z1), add(z0, add(z1, z2))), LE(z0, z1))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   HEAD(add(z0, z1)) -> c13
   TAIL(add(z0, z1)) -> c14
   TAIL(nil) -> c15
   NULL(nil) -> c16
   NULL(add(z0, z1)) -> c17
   RM(z0, nil) -> c18
   RM(z0, add(z1, z2)) -> c19(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MINSORT(z0) -> c22(MINS(z0, nil, nil))
   MINS(z0, z1, z2) -> c23(IF(null(z0), z0, z1, z2), NULL(z0))
   IF(true, z0, z1, z2) -> c24
   IF(false, z0, z1, z2) -> c25(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)), HEAD(z0))
   IF(false, z0, z1, z2) -> c26(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)), MIN(z0))
   IF2(true, z0, z1, z2) -> c27(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)), HEAD(z0))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)), TAIL(z0))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)), HEAD(z0))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2), TAIL(z0))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2), HEAD(z0))
S tuples:
   EQ(0, 0) -> c
   EQ(0, s(z0)) -> c1
   EQ(s(z0), 0) -> c2
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(0, z0) -> c4
   LE(s(z0), 0) -> c5
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(nil, z0) -> c7
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, nil)) -> c9
   MIN(add(z0, add(z1, z2))) -> c10(IF_MIN(le(z0, z1), add(z0, add(z1, z2))), LE(z0, z1))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   HEAD(add(z0, z1)) -> c13
   TAIL(add(z0, z1)) -> c14
   TAIL(nil) -> c15
   NULL(nil) -> c16
   NULL(add(z0, z1)) -> c17
   RM(z0, nil) -> c18
   RM(z0, add(z1, z2)) -> c19(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MINSORT(z0) -> c22(MINS(z0, nil, nil))
   MINS(z0, z1, z2) -> c23(IF(null(z0), z0, z1, z2), NULL(z0))
   IF(true, z0, z1, z2) -> c24
   IF(false, z0, z1, z2) -> c25(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)), HEAD(z0))
   IF(false, z0, z1, z2) -> c26(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)), MIN(z0))
   IF2(true, z0, z1, z2) -> c27(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)), HEAD(z0))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)), TAIL(z0))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)), HEAD(z0))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2), TAIL(z0))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2), HEAD(z0))
K tuples:none
Defined Rule Symbols:   eq_2, le_2, app_2, min_1, if_min_2, head_1, tail_1, null_1, rm_2, if_rm_3, minsort_1, mins_3, if_4, if2_4

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, IF_MIN_2, HEAD_1, TAIL_1, NULL_1, RM_2, IF_RM_3, MINSORT_1, MINS_3, IF_4, IF2_4

Compound Symbols:   c, c1, c2, c3_1, c4, c5, c6_1, c7, c8_1, c9, c10_2, c11_1, c12_1, c13, c14, c15, c16, c17, c18, c19_2, c20_1, c21_1, c22_1, c23_2, c24, c25_3, c26_3, c27_4, c28_4, c29_3, c30_2, c31_2


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

(79) CdtLeafRemovalProof (ComplexityIfPolyImplication)
Removed 1 leading nodes:
   MINSORT(z0) -> c22(MINS(z0, nil, nil))
Removed 14 trailing nodes:
   TAIL(nil) -> c15
   IF(true, z0, z1, z2) -> c24
   NULL(nil) -> c16
   EQ(0, 0) -> c
   LE(0, z0) -> c4
   NULL(add(z0, z1)) -> c17
   LE(s(z0), 0) -> c5
   APP(nil, z0) -> c7
   EQ(s(z0), 0) -> c2
   EQ(0, s(z0)) -> c1
   TAIL(add(z0, z1)) -> c14
   RM(z0, nil) -> c18
   HEAD(add(z0, z1)) -> c13
   MIN(add(z0, nil)) -> c9

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

(80)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   head(add(z0, z1)) -> z0
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   null(nil) -> true
   null(add(z0, z1)) -> false
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   minsort(z0) -> mins(z0, nil, nil)
   mins(z0, z1, z2) -> if(null(z0), z0, z1, z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> if2(eq(head(z0), min(z0)), z0, z1, z2)
   if2(true, z0, z1, z2) -> mins(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil)))
   if2(false, z0, z1, z2) -> mins(tail(z0), add(head(z0), z1), z2)
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, add(z1, z2))) -> c10(IF_MIN(le(z0, z1), add(z0, add(z1, z2))), LE(z0, z1))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   RM(z0, add(z1, z2)) -> c19(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MINS(z0, z1, z2) -> c23(IF(null(z0), z0, z1, z2), NULL(z0))
   IF(false, z0, z1, z2) -> c25(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)), HEAD(z0))
   IF(false, z0, z1, z2) -> c26(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)), MIN(z0))
   IF2(true, z0, z1, z2) -> c27(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)), HEAD(z0))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)), TAIL(z0))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)), HEAD(z0))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2), TAIL(z0))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2), HEAD(z0))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, add(z1, z2))) -> c10(IF_MIN(le(z0, z1), add(z0, add(z1, z2))), LE(z0, z1))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   RM(z0, add(z1, z2)) -> c19(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MINS(z0, z1, z2) -> c23(IF(null(z0), z0, z1, z2), NULL(z0))
   IF(false, z0, z1, z2) -> c25(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)), HEAD(z0))
   IF(false, z0, z1, z2) -> c26(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)), MIN(z0))
   IF2(true, z0, z1, z2) -> c27(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)), HEAD(z0))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)), TAIL(z0))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)), HEAD(z0))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2), TAIL(z0))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2), HEAD(z0))
K tuples:none
Defined Rule Symbols:   eq_2, le_2, app_2, min_1, if_min_2, head_1, tail_1, null_1, rm_2, if_rm_3, minsort_1, mins_3, if_4, if2_4

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, IF_MIN_2, RM_2, IF_RM_3, MINS_3, IF_4, IF2_4

Compound Symbols:   c3_1, c6_1, c8_1, c10_2, c11_1, c12_1, c19_2, c20_1, c21_1, c23_2, c25_3, c26_3, c27_4, c28_4, c29_3, c30_2, c31_2


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

(81) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 7 trailing tuple parts
----------------------------------------

(82)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   head(add(z0, z1)) -> z0
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   null(nil) -> true
   null(add(z0, z1)) -> false
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   minsort(z0) -> mins(z0, nil, nil)
   mins(z0, z1, z2) -> if(null(z0), z0, z1, z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> if2(eq(head(z0), min(z0)), z0, z1, z2)
   if2(true, z0, z1, z2) -> mins(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil)))
   if2(false, z0, z1, z2) -> mins(tail(z0), add(head(z0), z1), z2)
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, add(z1, z2))) -> c10(IF_MIN(le(z0, z1), add(z0, add(z1, z2))), LE(z0, z1))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   RM(z0, add(z1, z2)) -> c19(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF(false, z0, z1, z2) -> c26(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)), MIN(z0))
   MINS(z0, z1, z2) -> c23(IF(null(z0), z0, z1, z2))
   IF(false, z0, z1, z2) -> c25(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)))
   IF2(true, z0, z1, z2) -> c27(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, add(z1, z2))) -> c10(IF_MIN(le(z0, z1), add(z0, add(z1, z2))), LE(z0, z1))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   RM(z0, add(z1, z2)) -> c19(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF(false, z0, z1, z2) -> c26(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)), MIN(z0))
   MINS(z0, z1, z2) -> c23(IF(null(z0), z0, z1, z2))
   IF(false, z0, z1, z2) -> c25(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)))
   IF2(true, z0, z1, z2) -> c27(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
K tuples:none
Defined Rule Symbols:   eq_2, le_2, app_2, min_1, if_min_2, head_1, tail_1, null_1, rm_2, if_rm_3, minsort_1, mins_3, if_4, if2_4

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, IF_MIN_2, RM_2, IF_RM_3, IF_4, MINS_3, IF2_4

Compound Symbols:   c3_1, c6_1, c8_1, c10_2, c11_1, c12_1, c19_2, c20_1, c21_1, c26_3, c23_1, c25_2, c27_3, c28_3, c29_2, c30_1, c31_1


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

(83) CdtUsableRulesProof (BOTH BOUNDS(ID, ID))
The following rules are not usable and were removed:
   minsort(z0) -> mins(z0, nil, nil)
   mins(z0, z1, z2) -> if(null(z0), z0, z1, z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> if2(eq(head(z0), min(z0)), z0, z1, z2)
   if2(true, z0, z1, z2) -> mins(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil)))
   if2(false, z0, z1, z2) -> mins(tail(z0), add(head(z0), z1), z2)

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

(84)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   null(nil) -> true
   null(add(z0, z1)) -> false
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, add(z1, z2))) -> c10(IF_MIN(le(z0, z1), add(z0, add(z1, z2))), LE(z0, z1))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   RM(z0, add(z1, z2)) -> c19(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF(false, z0, z1, z2) -> c26(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)), MIN(z0))
   MINS(z0, z1, z2) -> c23(IF(null(z0), z0, z1, z2))
   IF(false, z0, z1, z2) -> c25(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)))
   IF2(true, z0, z1, z2) -> c27(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   MIN(add(z0, add(z1, z2))) -> c10(IF_MIN(le(z0, z1), add(z0, add(z1, z2))), LE(z0, z1))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   RM(z0, add(z1, z2)) -> c19(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF(false, z0, z1, z2) -> c26(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)), MIN(z0))
   MINS(z0, z1, z2) -> c23(IF(null(z0), z0, z1, z2))
   IF(false, z0, z1, z2) -> c25(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)))
   IF2(true, z0, z1, z2) -> c27(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
K tuples:none
Defined Rule Symbols:   le_2, eq_2, head_1, min_1, if_min_2, null_1, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, MIN_1, IF_MIN_2, RM_2, IF_RM_3, IF_4, MINS_3, IF2_4

Compound Symbols:   c3_1, c6_1, c8_1, c10_2, c11_1, c12_1, c19_2, c20_1, c21_1, c26_3, c23_1, c25_2, c27_3, c28_3, c29_2, c30_1, c31_1


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

(85) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MIN(add(z0, add(z1, z2))) -> c10(IF_MIN(le(z0, z1), add(z0, add(z1, z2))), LE(z0, z1)) by 
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))), LE(0, z0))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))), LE(s(z0), 0))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))

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

(86)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   null(nil) -> true
   null(add(z0, z1)) -> false
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   RM(z0, add(z1, z2)) -> c19(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF(false, z0, z1, z2) -> c26(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)), MIN(z0))
   MINS(z0, z1, z2) -> c23(IF(null(z0), z0, z1, z2))
   IF(false, z0, z1, z2) -> c25(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)))
   IF2(true, z0, z1, z2) -> c27(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))), LE(0, z0))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))), LE(s(z0), 0))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   RM(z0, add(z1, z2)) -> c19(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF(false, z0, z1, z2) -> c26(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)), MIN(z0))
   MINS(z0, z1, z2) -> c23(IF(null(z0), z0, z1, z2))
   IF(false, z0, z1, z2) -> c25(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)))
   IF2(true, z0, z1, z2) -> c27(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))), LE(0, z0))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))), LE(s(z0), 0))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
K tuples:none
Defined Rule Symbols:   le_2, eq_2, head_1, min_1, if_min_2, null_1, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, RM_2, IF_RM_3, IF_4, MINS_3, IF2_4, MIN_1

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c19_2, c20_1, c21_1, c26_3, c23_1, c25_2, c27_3, c28_3, c29_2, c30_1, c31_1, c10_2


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

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

(88)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   null(nil) -> true
   null(add(z0, z1)) -> false
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   RM(z0, add(z1, z2)) -> c19(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF(false, z0, z1, z2) -> c26(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)), MIN(z0))
   MINS(z0, z1, z2) -> c23(IF(null(z0), z0, z1, z2))
   IF(false, z0, z1, z2) -> c25(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)))
   IF2(true, z0, z1, z2) -> c27(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   RM(z0, add(z1, z2)) -> c19(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF(false, z0, z1, z2) -> c26(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)), MIN(z0))
   MINS(z0, z1, z2) -> c23(IF(null(z0), z0, z1, z2))
   IF(false, z0, z1, z2) -> c25(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)))
   IF2(true, z0, z1, z2) -> c27(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
K tuples:none
Defined Rule Symbols:   le_2, eq_2, head_1, min_1, if_min_2, null_1, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, RM_2, IF_RM_3, IF_4, MINS_3, IF2_4, MIN_1

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c19_2, c20_1, c21_1, c26_3, c23_1, c25_2, c27_3, c28_3, c29_2, c30_1, c31_1, c10_2, c10_1


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

(89) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace RM(z0, add(z1, z2)) -> c19(IF_RM(eq(z0, z1), z0, add(z1, z2)), EQ(z0, z1)) by 
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)), EQ(0, 0))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)), EQ(0, s(z0)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)), EQ(s(z0), 0))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))

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

(90)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   null(nil) -> true
   null(add(z0, z1)) -> false
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF(false, z0, z1, z2) -> c26(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)), MIN(z0))
   MINS(z0, z1, z2) -> c23(IF(null(z0), z0, z1, z2))
   IF(false, z0, z1, z2) -> c25(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)))
   IF2(true, z0, z1, z2) -> c27(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)), EQ(0, 0))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)), EQ(0, s(z0)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)), EQ(s(z0), 0))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF(false, z0, z1, z2) -> c26(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)), MIN(z0))
   MINS(z0, z1, z2) -> c23(IF(null(z0), z0, z1, z2))
   IF(false, z0, z1, z2) -> c25(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)))
   IF2(true, z0, z1, z2) -> c27(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)), EQ(0, 0))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)), EQ(0, s(z0)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)), EQ(s(z0), 0))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
K tuples:none
Defined Rule Symbols:   le_2, eq_2, head_1, min_1, if_min_2, null_1, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, IF_4, MINS_3, IF2_4, MIN_1, RM_2

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c26_3, c23_1, c25_2, c27_3, c28_3, c29_2, c30_1, c31_1, c10_2, c10_1, c19_2


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

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

(92)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   null(nil) -> true
   null(add(z0, z1)) -> false
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF(false, z0, z1, z2) -> c26(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)), MIN(z0))
   MINS(z0, z1, z2) -> c23(IF(null(z0), z0, z1, z2))
   IF(false, z0, z1, z2) -> c25(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)))
   IF2(true, z0, z1, z2) -> c27(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF(false, z0, z1, z2) -> c26(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)), MIN(z0))
   MINS(z0, z1, z2) -> c23(IF(null(z0), z0, z1, z2))
   IF(false, z0, z1, z2) -> c25(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)))
   IF2(true, z0, z1, z2) -> c27(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
K tuples:none
Defined Rule Symbols:   le_2, eq_2, head_1, min_1, if_min_2, null_1, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, IF_4, MINS_3, IF2_4, MIN_1, RM_2

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c26_3, c23_1, c25_2, c27_3, c28_3, c29_2, c30_1, c31_1, c10_2, c10_1, c19_2, c19_1


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

(93) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF(false, z0, z1, z2) -> c26(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)), MIN(z0)) by 
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))), MIN(add(z0, nil)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))

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

(94)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   null(nil) -> true
   null(add(z0, z1)) -> false
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MINS(z0, z1, z2) -> c23(IF(null(z0), z0, z1, z2))
   IF(false, z0, z1, z2) -> c25(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)))
   IF2(true, z0, z1, z2) -> c27(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))), MIN(add(z0, nil)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MINS(z0, z1, z2) -> c23(IF(null(z0), z0, z1, z2))
   IF(false, z0, z1, z2) -> c25(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)))
   IF2(true, z0, z1, z2) -> c27(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))), MIN(add(z0, nil)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
K tuples:none
Defined Rule Symbols:   le_2, eq_2, head_1, min_1, if_min_2, null_1, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MINS_3, IF_4, IF2_4, MIN_1, RM_2

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c23_1, c25_2, c27_3, c28_3, c29_2, c30_1, c31_1, c10_2, c10_1, c19_2, c19_1, c26_3


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

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

(96)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   null(nil) -> true
   null(add(z0, z1)) -> false
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MINS(z0, z1, z2) -> c23(IF(null(z0), z0, z1, z2))
   IF(false, z0, z1, z2) -> c25(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)))
   IF2(true, z0, z1, z2) -> c27(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MINS(z0, z1, z2) -> c23(IF(null(z0), z0, z1, z2))
   IF(false, z0, z1, z2) -> c25(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)))
   IF2(true, z0, z1, z2) -> c27(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
K tuples:none
Defined Rule Symbols:   le_2, eq_2, head_1, min_1, if_min_2, null_1, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MINS_3, IF_4, IF2_4, MIN_1, RM_2

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c23_1, c25_2, c27_3, c28_3, c29_2, c30_1, c31_1, c10_2, c10_1, c19_2, c19_1, c26_3, c26_2


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

(97) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MINS(z0, z1, z2) -> c23(IF(null(z0), z0, z1, z2)) by 
   MINS(nil, x1, x2) -> c23(IF(true, nil, x1, x2))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))

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

(98)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   null(nil) -> true
   null(add(z0, z1)) -> false
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF(false, z0, z1, z2) -> c25(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)))
   IF2(true, z0, z1, z2) -> c27(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(nil, x1, x2) -> c23(IF(true, nil, x1, x2))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF(false, z0, z1, z2) -> c25(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)))
   IF2(true, z0, z1, z2) -> c27(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(nil, x1, x2) -> c23(IF(true, nil, x1, x2))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
K tuples:none
Defined Rule Symbols:   le_2, eq_2, head_1, min_1, if_min_2, null_1, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, IF_4, IF2_4, MIN_1, RM_2, MINS_3

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c25_2, c27_3, c28_3, c29_2, c30_1, c31_1, c10_2, c10_1, c19_2, c19_1, c26_3, c26_2, c23_1


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

(99) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   MINS(nil, x1, x2) -> c23(IF(true, nil, x1, x2))

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

(100)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   null(nil) -> true
   null(add(z0, z1)) -> false
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF(false, z0, z1, z2) -> c25(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)))
   IF2(true, z0, z1, z2) -> c27(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF(false, z0, z1, z2) -> c25(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)))
   IF2(true, z0, z1, z2) -> c27(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
K tuples:none
Defined Rule Symbols:   le_2, eq_2, head_1, min_1, if_min_2, null_1, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, IF_4, IF2_4, MIN_1, RM_2, MINS_3

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c25_2, c27_3, c28_3, c29_2, c30_1, c31_1, c10_2, c10_1, c19_2, c19_1, c26_3, c26_2, c23_1


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

(101) CdtUsableRulesProof (BOTH BOUNDS(ID, ID))
The following rules are not usable and were removed:
   null(nil) -> true
   null(add(z0, z1)) -> false

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

(102)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF(false, z0, z1, z2) -> c25(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)))
   IF2(true, z0, z1, z2) -> c27(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF(false, z0, z1, z2) -> c25(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0)))
   IF2(true, z0, z1, z2) -> c27(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
K tuples:none
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, IF_4, IF2_4, MIN_1, RM_2, MINS_3

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c25_2, c27_3, c28_3, c29_2, c30_1, c31_1, c10_2, c10_1, c19_2, c19_1, c26_3, c26_2, c23_1


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

(103) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF(false, z0, z1, z2) -> c25(IF2(eq(head(z0), min(z0)), z0, z1, z2), EQ(head(z0), min(z0))) by 
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))

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

(104)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(true, z0, z1, z2) -> c27(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(true, z0, z1, z2) -> c27(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
K tuples:none
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, IF2_4, MIN_1, RM_2, IF_4, MINS_3

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c27_3, c28_3, c29_2, c30_1, c31_1, c10_2, c10_1, c19_2, c19_1, c26_3, c26_2, c23_1, c25_2


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

(105) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF2(true, z0, z1, z2) -> c27(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0))) by 
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c27(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))), APP(rm(head(nil), tail(nil)), x1), RM(head(nil), tail(nil)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))

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

(106)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c27(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))), APP(rm(head(nil), tail(nil)), x1), RM(head(nil), tail(nil)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c27(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))), APP(rm(head(nil), tail(nil)), x1), RM(head(nil), tail(nil)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
K tuples:none
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, IF2_4, MIN_1, RM_2, IF_4, MINS_3

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c28_3, c29_2, c30_1, c31_1, c10_2, c10_1, c19_2, c19_1, c26_3, c26_2, c23_1, c25_2, c27_3


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

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

(108)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c27(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))), APP(rm(head(nil), tail(nil)), x1))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c27(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))), APP(rm(head(nil), tail(nil)), x1))
K tuples:none
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, IF2_4, MIN_1, RM_2, IF_4, MINS_3

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c28_3, c29_2, c30_1, c31_1, c10_2, c10_1, c19_2, c19_1, c26_3, c26_2, c23_1, c25_2, c27_3, c27_2


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

(109) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID))
Split RHS of tuples not part of any SCC
----------------------------------------

(110)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
K tuples:none
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, IF2_4, MIN_1, RM_2, IF_4, MINS_3

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c28_3, c29_2, c30_1, c31_1, c10_2, c10_1, c19_2, c19_1, c26_3, c26_2, c23_1, c25_2, c27_3, c_1


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

(111) CdtKnowledgeProof (BOTH BOUNDS(ID, ID))
The following tuples could be moved from S to K by knowledge propagation:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))

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

(112)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, IF2_4, MIN_1, RM_2, IF_4, MINS_3

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c28_3, c29_2, c30_1, c31_1, c10_2, c10_1, c19_2, c19_1, c26_3, c26_2, c23_1, c25_2, c27_3, c_1


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

(113) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
We considered the (Usable) Rules:
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   app(nil, z0) -> z0
And the Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(APP(x_1, x_2)) = 0
   POL(EQ(x_1, x_2)) = 0
   POL(IF(x_1, x_2, x_3, x_4)) = x_1 + x_4
   POL(IF2(x_1, x_2, x_3, x_4)) = x_4
   POL(IF_MIN(x_1, x_2)) = x_2
   POL(IF_RM(x_1, x_2, x_3)) = x_3
   POL(LE(x_1, x_2)) = 0
   POL(MIN(x_1)) = x_1
   POL(MINS(x_1, x_2, x_3)) = x_3
   POL(RM(x_1, x_2)) = 0
   POL(add(x_1, x_2)) = 0
   POL(app(x_1, x_2)) = x_2
   POL(c(x_1)) = x_1
   POL(c10(x_1)) = x_1
   POL(c10(x_1, x_2)) = x_1 + x_2
   POL(c11(x_1)) = x_1
   POL(c12(x_1)) = x_1
   POL(c19(x_1)) = x_1
   POL(c19(x_1, x_2)) = x_1 + x_2
   POL(c20(x_1)) = x_1
   POL(c21(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c25(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c27(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c28(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c29(x_1, x_2)) = x_1 + x_2
   POL(c3(x_1)) = x_1
   POL(c30(x_1)) = x_1
   POL(c31(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(eq(x_1, x_2)) = 0
   POL(false) = 0
   POL(head(x_1)) = 0
   POL(if_min(x_1, x_2)) = [1] + x_2
   POL(if_rm(x_1, x_2, x_3)) = [1] + x_2 + x_3
   POL(le(x_1, x_2)) = 0
   POL(min(x_1)) = [1]
   POL(nil) = [1]
   POL(rm(x_1, x_2)) = x_1
   POL(s(x_1)) = 0
   POL(tail(x_1)) = 0
   POL(true) = 0

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

(114)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0)))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, IF2_4, MIN_1, RM_2, IF_4, MINS_3

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c28_3, c29_2, c30_1, c31_1, c10_2, c10_1, c19_2, c19_1, c26_3, c26_2, c23_1, c25_2, c27_3, c_1


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

(115) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF2(true, z0, z1, z2) -> c28(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(rm(head(z0), tail(z0)), z1), RM(head(z0), tail(z0))) by 
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c28(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))), APP(rm(head(nil), tail(nil)), x1), RM(head(nil), tail(nil)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))

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

(116)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c28(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))), APP(rm(head(nil), tail(nil)), x1), RM(head(nil), tail(nil)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c28(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))), APP(rm(head(nil), tail(nil)), x1), RM(head(nil), tail(nil)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, IF2_4, MIN_1, RM_2, IF_4, MINS_3

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c29_2, c30_1, c31_1, c10_2, c10_1, c19_2, c19_1, c26_3, c26_2, c23_1, c25_2, c27_3, c_1, c28_3


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

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

(118)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c28(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))), APP(rm(head(nil), tail(nil)), x1))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c28(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))), APP(rm(head(nil), tail(nil)), x1))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, IF2_4, MIN_1, RM_2, IF_4, MINS_3

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c29_2, c30_1, c31_1, c10_2, c10_1, c19_2, c19_1, c26_3, c26_2, c23_1, c25_2, c27_3, c_1, c28_3, c28_2


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

(119) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID))
Split RHS of tuples not part of any SCC
----------------------------------------

(120)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, IF2_4, MIN_1, RM_2, IF_4, MINS_3

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c29_2, c30_1, c31_1, c10_2, c10_1, c19_2, c19_1, c26_3, c26_2, c23_1, c25_2, c27_3, c_1, c28_3, c1_1


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

(121) CdtKnowledgeProof (BOTH BOUNDS(ID, ID))
The following tuples could be moved from S to K by knowledge propagation:
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))

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

(122)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, IF2_4, MIN_1, RM_2, IF_4, MINS_3

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c29_2, c30_1, c31_1, c10_2, c10_1, c19_2, c19_1, c26_3, c26_2, c23_1, c25_2, c27_3, c_1, c28_3, c1_1


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

(123) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
We considered the (Usable) Rules:
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   app(nil, z0) -> z0
And the Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(APP(x_1, x_2)) = 0
   POL(EQ(x_1, x_2)) = 0
   POL(IF(x_1, x_2, x_3, x_4)) = x_1 + x_4
   POL(IF2(x_1, x_2, x_3, x_4)) = x_4
   POL(IF_MIN(x_1, x_2)) = x_2
   POL(IF_RM(x_1, x_2, x_3)) = x_3
   POL(LE(x_1, x_2)) = 0
   POL(MIN(x_1)) = x_1
   POL(MINS(x_1, x_2, x_3)) = x_3
   POL(RM(x_1, x_2)) = 0
   POL(add(x_1, x_2)) = 0
   POL(app(x_1, x_2)) = x_2
   POL(c(x_1)) = x_1
   POL(c1(x_1)) = x_1
   POL(c10(x_1)) = x_1
   POL(c10(x_1, x_2)) = x_1 + x_2
   POL(c11(x_1)) = x_1
   POL(c12(x_1)) = x_1
   POL(c19(x_1)) = x_1
   POL(c19(x_1, x_2)) = x_1 + x_2
   POL(c20(x_1)) = x_1
   POL(c21(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c25(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c27(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c28(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c29(x_1, x_2)) = x_1 + x_2
   POL(c3(x_1)) = x_1
   POL(c30(x_1)) = x_1
   POL(c31(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(eq(x_1, x_2)) = 0
   POL(false) = 0
   POL(head(x_1)) = 0
   POL(if_min(x_1, x_2)) = [1] + x_2
   POL(if_rm(x_1, x_2, x_3)) = [1] + x_2 + x_3
   POL(le(x_1, x_2)) = 0
   POL(min(x_1)) = [1]
   POL(nil) = [1]
   POL(rm(x_1, x_2)) = x_1
   POL(s(x_1)) = 0
   POL(tail(x_1)) = 0
   POL(true) = 0

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

(124)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil)))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, IF2_4, MIN_1, RM_2, IF_4, MINS_3

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c29_2, c30_1, c31_1, c10_2, c10_1, c19_2, c19_1, c26_3, c26_2, c23_1, c25_2, c27_3, c_1, c28_3, c1_1


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

(125) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF2(true, z0, z1, z2) -> c29(MINS(app(rm(head(z0), tail(z0)), z1), nil, app(z2, add(head(z0), nil))), APP(z2, add(head(z0), nil))) by 
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(nil, add(head(x0), nil)))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, nil, x1, x2) -> c29(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))), APP(x2, add(head(nil), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))

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

(126)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(nil, add(head(x0), nil)))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, nil, x1, x2) -> c29(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))), APP(x2, add(head(nil), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(nil, add(head(x0), nil)))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, nil, x1, x2) -> c29(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))), APP(x2, add(head(nil), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, IF2_4, MIN_1, RM_2, IF_4, MINS_3

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c30_1, c31_1, c10_2, c10_1, c19_2, c19_1, c26_3, c26_2, c23_1, c25_2, c27_3, c_1, c28_3, c1_1, c29_2


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

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

(128)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, nil, x1, x2) -> c29(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))), APP(x2, add(head(nil), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, nil, x1, x2) -> c29(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))), APP(x2, add(head(nil), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, IF2_4, MIN_1, RM_2, IF_4, MINS_3

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c30_1, c31_1, c10_2, c10_1, c19_2, c19_1, c26_3, c26_2, c23_1, c25_2, c27_3, c_1, c28_3, c1_1, c29_2, c29_1


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

(129) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID))
Split RHS of tuples not part of any SCC
----------------------------------------

(130)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, IF2_4, MIN_1, RM_2, IF_4, MINS_3

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c30_1, c31_1, c10_2, c10_1, c19_2, c19_1, c26_3, c26_2, c23_1, c25_2, c27_3, c_1, c28_3, c1_1, c29_2, c29_1, c2_1


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

(131) CdtKnowledgeProof (BOTH BOUNDS(ID, ID))
The following tuples could be moved from S to K by knowledge propagation:
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))

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

(132)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, IF2_4, MIN_1, RM_2, IF_4, MINS_3

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c30_1, c31_1, c10_2, c10_1, c19_2, c19_1, c26_3, c26_2, c23_1, c25_2, c27_3, c_1, c28_3, c1_1, c29_2, c29_1, c2_1


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

(133) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
We considered the (Usable) Rules:
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   app(nil, z0) -> z0
And the Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(APP(x_1, x_2)) = 0
   POL(EQ(x_1, x_2)) = 0
   POL(IF(x_1, x_2, x_3, x_4)) = x_1 + x_4
   POL(IF2(x_1, x_2, x_3, x_4)) = x_4
   POL(IF_MIN(x_1, x_2)) = x_2
   POL(IF_RM(x_1, x_2, x_3)) = x_3
   POL(LE(x_1, x_2)) = 0
   POL(MIN(x_1)) = x_1
   POL(MINS(x_1, x_2, x_3)) = x_3
   POL(RM(x_1, x_2)) = 0
   POL(add(x_1, x_2)) = 0
   POL(app(x_1, x_2)) = x_2
   POL(c(x_1)) = x_1
   POL(c1(x_1)) = x_1
   POL(c10(x_1)) = x_1
   POL(c10(x_1, x_2)) = x_1 + x_2
   POL(c11(x_1)) = x_1
   POL(c12(x_1)) = x_1
   POL(c19(x_1)) = x_1
   POL(c19(x_1, x_2)) = x_1 + x_2
   POL(c2(x_1)) = x_1
   POL(c20(x_1)) = x_1
   POL(c21(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c25(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c27(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c28(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c29(x_1)) = x_1
   POL(c29(x_1, x_2)) = x_1 + x_2
   POL(c3(x_1)) = x_1
   POL(c30(x_1)) = x_1
   POL(c31(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(eq(x_1, x_2)) = 0
   POL(false) = 0
   POL(head(x_1)) = 0
   POL(if_min(x_1, x_2)) = [1] + x_2
   POL(if_rm(x_1, x_2, x_3)) = [1] + x_2 + x_3
   POL(le(x_1, x_2)) = 0
   POL(min(x_1)) = [1]
   POL(nil) = [1]
   POL(rm(x_1, x_2)) = x_1
   POL(s(x_1)) = 0
   POL(tail(x_1)) = 0
   POL(true) = 0

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

(134)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, IF2_4, MIN_1, RM_2, IF_4, MINS_3

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c30_1, c31_1, c10_2, c10_1, c19_2, c19_1, c26_3, c26_2, c23_1, c25_2, c27_3, c_1, c28_3, c1_1, c29_2, c29_1, c2_1


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

(135) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF2(false, z0, z1, z2) -> c30(MINS(tail(z0), add(head(z0), z1), z2)) by 
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, nil, x1, x2) -> c30(MINS(nil, add(head(nil), x1), x2))

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

(136)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, nil, x1, x2) -> c30(MINS(nil, add(head(nil), x1), x2))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, nil, x1, x2) -> c30(MINS(nil, add(head(nil), x1), x2))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, IF2_4, MIN_1, RM_2, IF_4, MINS_3

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c31_1, c10_2, c10_1, c19_2, c19_1, c26_3, c26_2, c23_1, c25_2, c27_3, c_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1


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

(137) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   IF2(false, nil, x1, x2) -> c30(MINS(nil, add(head(nil), x1), x2))

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

(138)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, IF2_4, MIN_1, RM_2, IF_4, MINS_3

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c31_1, c10_2, c10_1, c19_2, c19_1, c26_3, c26_2, c23_1, c25_2, c27_3, c_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1


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

(139) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF2(false, z0, z1, z2) -> c31(MINS(tail(z0), add(head(z0), z1), z2)) by 
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, nil, x1, x2) -> c31(MINS(nil, add(head(nil), x1), x2))

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

(140)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, nil, x1, x2) -> c31(MINS(nil, add(head(nil), x1), x2))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, nil, x1, x2) -> c31(MINS(nil, add(head(nil), x1), x2))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, IF_4, MINS_3, IF2_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_2, c10_1, c19_2, c19_1, c26_3, c26_2, c23_1, c25_2, c27_3, c_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1


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

(141) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   IF2(false, nil, x1, x2) -> c31(MINS(nil, add(head(nil), x1), x2))

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

(142)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1)))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, IF_4, MINS_3, IF2_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_2, c10_1, c19_2, c19_1, c26_3, c26_2, c23_1, c25_2, c27_3, c_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1


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

(143) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MIN(add(s(z0), add(s(z1), x2))) -> c10(IF_MIN(le(z0, z1), add(s(z0), add(s(z1), x2))), LE(s(z0), s(z1))) by 
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))

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

(144)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1)))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, IF_4, MINS_3, IF2_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_2, c19_1, c26_3, c26_2, c23_1, c25_2, c27_3, c_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2


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

(145) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace RM(s(z0), add(s(z1), x2)) -> c19(IF_RM(eq(z0, z1), s(z0), add(s(z1), x2)), EQ(s(z0), s(z1))) by 
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))

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

(146)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, IF_4, MINS_3, IF2_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c26_3, c26_2, c23_1, c25_2, c27_3, c_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2


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

(147) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF(false, add(z0, add(z1, z2)), x1, x2) -> c26(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2)))) by 
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))

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

(148)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, IF_4, MINS_3, IF2_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c26_3, c26_2, c23_1, c25_2, c27_3, c_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_1


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

(149) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
We considered the (Usable) Rules:none
And the Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(APP(x_1, x_2)) = 0
   POL(EQ(x_1, x_2)) = 0
   POL(IF(x_1, x_2, x_3, x_4)) = x_1 + x_2
   POL(IF2(x_1, x_2, x_3, x_4)) = [1]
   POL(IF_MIN(x_1, x_2)) = 0
   POL(IF_RM(x_1, x_2, x_3)) = 0
   POL(LE(x_1, x_2)) = 0
   POL(MIN(x_1)) = 0
   POL(MINS(x_1, x_2, x_3)) = [1]
   POL(RM(x_1, x_2)) = 0
   POL(add(x_1, x_2)) = [1]
   POL(app(x_1, x_2)) = [1]
   POL(c(x_1)) = x_1
   POL(c1(x_1)) = x_1
   POL(c10(x_1)) = x_1
   POL(c10(x_1, x_2)) = x_1 + x_2
   POL(c11(x_1)) = x_1
   POL(c12(x_1)) = x_1
   POL(c19(x_1)) = x_1
   POL(c19(x_1, x_2)) = x_1 + x_2
   POL(c2(x_1)) = x_1
   POL(c20(x_1)) = x_1
   POL(c21(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c25(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1)) = x_1
   POL(c26(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c27(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c28(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c29(x_1)) = x_1
   POL(c29(x_1, x_2)) = x_1 + x_2
   POL(c3(x_1)) = x_1
   POL(c30(x_1)) = x_1
   POL(c31(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(eq(x_1, x_2)) = 0
   POL(false) = 0
   POL(head(x_1)) = 0
   POL(if_min(x_1, x_2)) = [1] + x_2
   POL(if_rm(x_1, x_2, x_3)) = [1] + x_2 + x_3
   POL(le(x_1, x_2)) = 0
   POL(min(x_1)) = [1]
   POL(nil) = 0
   POL(rm(x_1, x_2)) = x_1
   POL(s(x_1)) = 0
   POL(tail(x_1)) = 0
   POL(true) = 0

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

(150)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, IF_4, MINS_3, IF2_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c26_3, c26_2, c23_1, c25_2, c27_3, c_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_1


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

(151) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF(false, add(z0, z1), x1, x2) -> c26(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))), MIN(add(z0, z1))) by 
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))), MIN(add(z0, nil)))
   IF(false, add(z0, add(z1, z2)), x2, x3) -> c26(IF2(eq(z0, if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x2, x3), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))), MIN(add(z0, add(z1, z2))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))

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

(152)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))), MIN(add(z0, nil)))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))), MIN(add(z0, nil)))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, IF_4, MINS_3, IF2_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c26_2, c23_1, c25_2, c27_3, c_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1


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

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

(154)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, IF_4, MINS_3, IF2_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c26_2, c23_1, c25_2, c27_3, c_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1


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

(155) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
We considered the (Usable) Rules:
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   eq(0, 0) -> true
And the Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(APP(x_1, x_2)) = 0
   POL(EQ(x_1, x_2)) = 0
   POL(IF(x_1, x_2, x_3, x_4)) = x_1
   POL(IF2(x_1, x_2, x_3, x_4)) = x_1
   POL(IF_MIN(x_1, x_2)) = 0
   POL(IF_RM(x_1, x_2, x_3)) = 0
   POL(LE(x_1, x_2)) = 0
   POL(MIN(x_1)) = 0
   POL(MINS(x_1, x_2, x_3)) = [1]
   POL(RM(x_1, x_2)) = 0
   POL(add(x_1, x_2)) = 0
   POL(app(x_1, x_2)) = [1]
   POL(c(x_1)) = x_1
   POL(c1(x_1)) = x_1
   POL(c10(x_1)) = x_1
   POL(c10(x_1, x_2)) = x_1 + x_2
   POL(c11(x_1)) = x_1
   POL(c12(x_1)) = x_1
   POL(c19(x_1)) = x_1
   POL(c19(x_1, x_2)) = x_1 + x_2
   POL(c2(x_1)) = x_1
   POL(c20(x_1)) = x_1
   POL(c21(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c25(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1)) = x_1
   POL(c26(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c27(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c28(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c29(x_1)) = x_1
   POL(c29(x_1, x_2)) = x_1 + x_2
   POL(c3(x_1)) = x_1
   POL(c30(x_1)) = x_1
   POL(c31(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(eq(x_1, x_2)) = [1]
   POL(false) = [1]
   POL(head(x_1)) = 0
   POL(if_min(x_1, x_2)) = [1] + x_2
   POL(if_rm(x_1, x_2, x_3)) = [1] + x_2 + x_3
   POL(le(x_1, x_2)) = 0
   POL(min(x_1)) = [1]
   POL(nil) = 0
   POL(rm(x_1, x_2)) = x_1
   POL(s(x_1)) = 0
   POL(tail(x_1)) = 0
   POL(true) = [1]

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

(156)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, IF_4, MINS_3, IF2_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c26_2, c23_1, c25_2, c27_3, c_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1


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

(157) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil)))) by 
   IF(false, add(z0, nil), x1, x2) -> c26(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))

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

(158)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF_4, IF2_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c25_2, c27_3, c_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2


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

(159) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
We considered the (Usable) Rules:none
And the Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(APP(x_1, x_2)) = 0
   POL(EQ(x_1, x_2)) = 0
   POL(IF(x_1, x_2, x_3, x_4)) = [1] + [3]x_1
   POL(IF2(x_1, x_2, x_3, x_4)) = [1]
   POL(IF_MIN(x_1, x_2)) = 0
   POL(IF_RM(x_1, x_2, x_3)) = 0
   POL(LE(x_1, x_2)) = 0
   POL(MIN(x_1)) = 0
   POL(MINS(x_1, x_2, x_3)) = [1]
   POL(RM(x_1, x_2)) = 0
   POL(add(x_1, x_2)) = 0
   POL(app(x_1, x_2)) = 0
   POL(c(x_1)) = x_1
   POL(c1(x_1)) = x_1
   POL(c10(x_1)) = x_1
   POL(c10(x_1, x_2)) = x_1 + x_2
   POL(c11(x_1)) = x_1
   POL(c12(x_1)) = x_1
   POL(c19(x_1)) = x_1
   POL(c19(x_1, x_2)) = x_1 + x_2
   POL(c2(x_1)) = x_1
   POL(c20(x_1)) = x_1
   POL(c21(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c25(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1)) = x_1
   POL(c26(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c27(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c28(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c29(x_1)) = x_1
   POL(c29(x_1, x_2)) = x_1 + x_2
   POL(c3(x_1)) = x_1
   POL(c30(x_1)) = x_1
   POL(c31(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(eq(x_1, x_2)) = 0
   POL(false) = 0
   POL(head(x_1)) = 0
   POL(if_min(x_1, x_2)) = [3] + [3]x_2
   POL(if_rm(x_1, x_2, x_3)) = [3] + [3]x_2 + [3]x_3
   POL(le(x_1, x_2)) = 0
   POL(min(x_1)) = 0
   POL(nil) = 0
   POL(rm(x_1, x_2)) = 0
   POL(s(x_1)) = 0
   POL(tail(x_1)) = 0
   POL(true) = 0

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

(160)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF_4, IF2_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c25_2, c27_3, c_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2


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

(161) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(head(add(z0, nil)), z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil)))) by 
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))

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

(162)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF_4, IF2_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c25_2, c27_3, c_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_1


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

(163) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
We considered the (Usable) Rules:none
And the Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(APP(x_1, x_2)) = 0
   POL(EQ(x_1, x_2)) = 0
   POL(IF(x_1, x_2, x_3, x_4)) = [1] + x_1 + x_2
   POL(IF2(x_1, x_2, x_3, x_4)) = [1]
   POL(IF_MIN(x_1, x_2)) = x_2
   POL(IF_RM(x_1, x_2, x_3)) = x_3
   POL(LE(x_1, x_2)) = 0
   POL(MIN(x_1)) = x_1
   POL(MINS(x_1, x_2, x_3)) = [1]
   POL(RM(x_1, x_2)) = 0
   POL(add(x_1, x_2)) = 0
   POL(app(x_1, x_2)) = [1]
   POL(c(x_1)) = x_1
   POL(c1(x_1)) = x_1
   POL(c10(x_1)) = x_1
   POL(c10(x_1, x_2)) = x_1 + x_2
   POL(c11(x_1)) = x_1
   POL(c12(x_1)) = x_1
   POL(c19(x_1)) = x_1
   POL(c19(x_1, x_2)) = x_1 + x_2
   POL(c2(x_1)) = x_1
   POL(c20(x_1)) = x_1
   POL(c21(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c25(x_1)) = x_1
   POL(c25(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1)) = x_1
   POL(c26(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c27(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c28(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c29(x_1)) = x_1
   POL(c29(x_1, x_2)) = x_1 + x_2
   POL(c3(x_1)) = x_1
   POL(c30(x_1)) = x_1
   POL(c31(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(eq(x_1, x_2)) = 0
   POL(false) = 0
   POL(head(x_1)) = 0
   POL(if_min(x_1, x_2)) = [1] + x_2
   POL(if_rm(x_1, x_2, x_3)) = [1] + x_2 + x_3
   POL(le(x_1, x_2)) = 0
   POL(min(x_1)) = [1]
   POL(nil) = 0
   POL(rm(x_1, x_2)) = x_1
   POL(s(x_1)) = 0
   POL(tail(x_1)) = 0
   POL(true) = 0

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

(164)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF_4, IF2_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c25_2, c27_3, c_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_1


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

(165) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF(false, add(z0, add(z1, z2)), x1, x2) -> c25(IF2(eq(head(add(z0, add(z1, z2))), if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x1, x2), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2))))) by 
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))

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

(166)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF_4, IF2_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c25_2, c27_3, c_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_1


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

(167) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
We considered the (Usable) Rules:
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   eq(0, 0) -> true
And the Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(APP(x_1, x_2)) = 0
   POL(EQ(x_1, x_2)) = 0
   POL(IF(x_1, x_2, x_3, x_4)) = x_1 + x_2
   POL(IF2(x_1, x_2, x_3, x_4)) = x_1
   POL(IF_MIN(x_1, x_2)) = x_2
   POL(IF_RM(x_1, x_2, x_3)) = x_3
   POL(LE(x_1, x_2)) = 0
   POL(MIN(x_1)) = x_1
   POL(MINS(x_1, x_2, x_3)) = [1]
   POL(RM(x_1, x_2)) = 0
   POL(add(x_1, x_2)) = 0
   POL(app(x_1, x_2)) = [1]
   POL(c(x_1)) = x_1
   POL(c1(x_1)) = x_1
   POL(c10(x_1)) = x_1
   POL(c10(x_1, x_2)) = x_1 + x_2
   POL(c11(x_1)) = x_1
   POL(c12(x_1)) = x_1
   POL(c19(x_1)) = x_1
   POL(c19(x_1, x_2)) = x_1 + x_2
   POL(c2(x_1)) = x_1
   POL(c20(x_1)) = x_1
   POL(c21(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c25(x_1)) = x_1
   POL(c25(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1)) = x_1
   POL(c26(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c27(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c28(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c29(x_1)) = x_1
   POL(c29(x_1, x_2)) = x_1 + x_2
   POL(c3(x_1)) = x_1
   POL(c30(x_1)) = x_1
   POL(c31(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(eq(x_1, x_2)) = [1]
   POL(false) = [1]
   POL(head(x_1)) = 0
   POL(if_min(x_1, x_2)) = [1] + x_2
   POL(if_rm(x_1, x_2, x_3)) = [1] + x_2 + x_3
   POL(le(x_1, x_2)) = 0
   POL(min(x_1)) = [1]
   POL(nil) = 0
   POL(rm(x_1, x_2)) = x_1
   POL(s(x_1)) = 0
   POL(tail(x_1)) = 0
   POL(true) = [1]

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

(168)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF_4, IF2_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c25_2, c27_3, c_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_1


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

(169) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF(false, add(z0, z1), x1, x2) -> c25(IF2(eq(z0, min(add(z0, z1))), add(z0, z1), x1, x2), EQ(head(add(z0, z1)), min(add(z0, z1)))) by 
   IF(false, add(z0, nil), x2, x3) -> c25(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, add(z1, z2)), x2, x3) -> c25(IF2(eq(z0, if_min(le(z0, z1), add(z0, add(z1, z2)))), add(z0, add(z1, z2)), x2, x3), EQ(head(add(z0, add(z1, z2))), min(add(z0, add(z1, z2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))

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

(170)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c27_3, c_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1


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

(171) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
We considered the (Usable) Rules:none
And the Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(APP(x_1, x_2)) = 0
   POL(EQ(x_1, x_2)) = 0
   POL(IF(x_1, x_2, x_3, x_4)) = [1] + x_1 + x_2
   POL(IF2(x_1, x_2, x_3, x_4)) = [1]
   POL(IF_MIN(x_1, x_2)) = x_2
   POL(IF_RM(x_1, x_2, x_3)) = x_3
   POL(LE(x_1, x_2)) = 0
   POL(MIN(x_1)) = x_1
   POL(MINS(x_1, x_2, x_3)) = [1]
   POL(RM(x_1, x_2)) = 0
   POL(add(x_1, x_2)) = 0
   POL(app(x_1, x_2)) = [1]
   POL(c(x_1)) = x_1
   POL(c1(x_1)) = x_1
   POL(c10(x_1)) = x_1
   POL(c10(x_1, x_2)) = x_1 + x_2
   POL(c11(x_1)) = x_1
   POL(c12(x_1)) = x_1
   POL(c19(x_1)) = x_1
   POL(c19(x_1, x_2)) = x_1 + x_2
   POL(c2(x_1)) = x_1
   POL(c20(x_1)) = x_1
   POL(c21(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c25(x_1)) = x_1
   POL(c25(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1)) = x_1
   POL(c26(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c27(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c28(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c29(x_1)) = x_1
   POL(c29(x_1, x_2)) = x_1 + x_2
   POL(c3(x_1)) = x_1
   POL(c30(x_1)) = x_1
   POL(c31(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(eq(x_1, x_2)) = 0
   POL(false) = 0
   POL(head(x_1)) = 0
   POL(if_min(x_1, x_2)) = [1] + x_2
   POL(if_rm(x_1, x_2, x_3)) = [1] + x_2 + x_3
   POL(le(x_1, x_2)) = 0
   POL(min(x_1)) = [1]
   POL(nil) = 0
   POL(rm(x_1, x_2)) = x_1
   POL(s(x_1)) = 0
   POL(tail(x_1)) = 0
   POL(true) = 0

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

(172)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c27_3, c_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1


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

(173) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0))) by 
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c27(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)), APP(rm(head(nil), tail(nil)), x1), RM(head(nil), tail(nil)))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))

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

(174)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c27(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)), APP(rm(head(nil), tail(nil)), x1), RM(head(nil), tail(nil)))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c27_3, c_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1


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

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

(176)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c27(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)), APP(rm(head(nil), tail(nil)), x1))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c27_3, c_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_2


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

(177) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID))
Split RHS of tuples not part of any SCC
----------------------------------------

(178)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c27_3, c_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c4_1


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

(179) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF2(true, x0, x1, add(z0, z1)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0))) by 
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c27(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))), APP(rm(head(nil), tail(nil)), x1), RM(head(nil), tail(nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))

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

(180)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c27(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))), APP(rm(head(nil), tail(nil)), x1), RM(head(nil), tail(nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c27(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))), APP(rm(head(nil), tail(nil)), x1), RM(head(nil), tail(nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c27_3, c_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c4_1


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

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

(182)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c27(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))), APP(rm(head(nil), tail(nil)), x1))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c27(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))), APP(rm(head(nil), tail(nil)), x1))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c27_3, c_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c4_1, c27_2


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

(183) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID))
Split RHS of tuples not part of any SCC
----------------------------------------

(184)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c27_3, c_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c4_1, c5_1


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

(185) CdtKnowledgeProof (BOTH BOUNDS(ID, ID))
The following tuples could be moved from S to K by knowledge propagation:
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))

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

(186)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c27_3, c_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c4_1, c5_1


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

(187) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1)))) by 
   IF2(true, add(x0, x1), x2, nil) -> c27(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)), APP(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), RM(head(add(x0, x1)), tail(add(x0, x1))))
   IF2(true, add(x0, x1), x2, add(z0, z1)) -> c27(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(z0, app(z1, add(x0, nil)))), APP(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), RM(head(add(x0, x1)), tail(add(x0, x1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))

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

(188)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, x1), x2, nil) -> c27(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)), APP(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), RM(head(add(x0, x1)), tail(add(x0, x1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c27_3, c_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c4_1, c5_1


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

(189) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
We considered the (Usable) Rules:
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   app(nil, z0) -> z0
And the Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(APP(x_1, x_2)) = 0
   POL(EQ(x_1, x_2)) = 0
   POL(IF(x_1, x_2, x_3, x_4)) = x_1 + x_2 + x_4
   POL(IF2(x_1, x_2, x_3, x_4)) = x_4
   POL(IF_MIN(x_1, x_2)) = x_2
   POL(IF_RM(x_1, x_2, x_3)) = x_3
   POL(LE(x_1, x_2)) = 0
   POL(MIN(x_1)) = x_1
   POL(MINS(x_1, x_2, x_3)) = x_3
   POL(RM(x_1, x_2)) = 0
   POL(add(x_1, x_2)) = 0
   POL(app(x_1, x_2)) = x_2
   POL(c(x_1)) = x_1
   POL(c1(x_1)) = x_1
   POL(c10(x_1)) = x_1
   POL(c10(x_1, x_2)) = x_1 + x_2
   POL(c11(x_1)) = x_1
   POL(c12(x_1)) = x_1
   POL(c19(x_1)) = x_1
   POL(c19(x_1, x_2)) = x_1 + x_2
   POL(c2(x_1)) = x_1
   POL(c20(x_1)) = x_1
   POL(c21(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c25(x_1)) = x_1
   POL(c25(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1)) = x_1
   POL(c26(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c27(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c28(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c29(x_1)) = x_1
   POL(c29(x_1, x_2)) = x_1 + x_2
   POL(c3(x_1)) = x_1
   POL(c30(x_1)) = x_1
   POL(c31(x_1)) = x_1
   POL(c4(x_1)) = x_1
   POL(c5(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(eq(x_1, x_2)) = 0
   POL(false) = 0
   POL(head(x_1)) = 0
   POL(if_min(x_1, x_2)) = [1] + x_2
   POL(if_rm(x_1, x_2, x_3)) = [1] + x_2 + x_3
   POL(le(x_1, x_2)) = 0
   POL(min(x_1)) = [1]
   POL(nil) = [1]
   POL(rm(x_1, x_2)) = x_1
   POL(s(x_1)) = 0
   POL(tail(x_1)) = 0
   POL(true) = 0

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

(190)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c27_3, c_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c4_1, c5_1


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

(191) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1)))) by 
   IF2(true, add(x0, x1), x2, nil) -> c27(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)), APP(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), RM(head(add(x0, x1)), tail(add(x0, x1))))
   IF2(true, add(x0, x1), x2, add(z0, z1)) -> c27(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(z0, app(z1, add(head(add(x0, x1)), nil)))), APP(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), RM(head(add(x0, x1)), tail(add(x0, x1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))

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

(192)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, x1), x2, nil) -> c27(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)), APP(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), RM(head(add(x0, x1)), tail(add(x0, x1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c27_3, c_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c4_1, c5_1


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

(193) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
We considered the (Usable) Rules:
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   app(nil, z0) -> z0
And the Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(APP(x_1, x_2)) = 0
   POL(EQ(x_1, x_2)) = 0
   POL(IF(x_1, x_2, x_3, x_4)) = x_1 + x_4
   POL(IF2(x_1, x_2, x_3, x_4)) = x_4
   POL(IF_MIN(x_1, x_2)) = x_2
   POL(IF_RM(x_1, x_2, x_3)) = x_3
   POL(LE(x_1, x_2)) = 0
   POL(MIN(x_1)) = x_1
   POL(MINS(x_1, x_2, x_3)) = x_3
   POL(RM(x_1, x_2)) = 0
   POL(add(x_1, x_2)) = 0
   POL(app(x_1, x_2)) = x_2
   POL(c(x_1)) = x_1
   POL(c1(x_1)) = x_1
   POL(c10(x_1)) = x_1
   POL(c10(x_1, x_2)) = x_1 + x_2
   POL(c11(x_1)) = x_1
   POL(c12(x_1)) = x_1
   POL(c19(x_1)) = x_1
   POL(c19(x_1, x_2)) = x_1 + x_2
   POL(c2(x_1)) = x_1
   POL(c20(x_1)) = x_1
   POL(c21(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c25(x_1)) = x_1
   POL(c25(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1)) = x_1
   POL(c26(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c27(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c28(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c29(x_1)) = x_1
   POL(c29(x_1, x_2)) = x_1 + x_2
   POL(c3(x_1)) = x_1
   POL(c30(x_1)) = x_1
   POL(c31(x_1)) = x_1
   POL(c4(x_1)) = x_1
   POL(c5(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(eq(x_1, x_2)) = 0
   POL(false) = 0
   POL(head(x_1)) = 0
   POL(if_min(x_1, x_2)) = [1] + x_2
   POL(if_rm(x_1, x_2, x_3)) = [1] + x_2 + x_3
   POL(le(x_1, x_2)) = 0
   POL(min(x_1)) = [1]
   POL(nil) = [1]
   POL(rm(x_1, x_2)) = 0
   POL(s(x_1)) = 0
   POL(tail(x_1)) = 0
   POL(true) = 0

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

(194)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c27_3, c_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c4_1, c5_1


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

(195) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF2(true, add(z0, z1), x1, x2) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1)))) by 
   IF2(true, add(x0, x1), x2, nil) -> c27(MINS(app(rm(x0, tail(add(x0, x1))), x2), nil, add(head(add(x0, x1)), nil)), APP(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), RM(head(add(x0, x1)), tail(add(x0, x1))))
   IF2(true, add(x0, x1), x2, add(z0, z1)) -> c27(MINS(app(rm(x0, tail(add(x0, x1))), x2), nil, add(z0, app(z1, add(head(add(x0, x1)), nil)))), APP(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), RM(head(add(x0, x1)), tail(add(x0, x1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))

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

(196)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, x1), x2, nil) -> c27(MINS(app(rm(x0, tail(add(x0, x1))), x2), nil, add(head(add(x0, x1)), nil)), APP(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), RM(head(add(x0, x1)), tail(add(x0, x1))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1


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

(197) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
We considered the (Usable) Rules:
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   app(nil, z0) -> z0
And the Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(APP(x_1, x_2)) = 0
   POL(EQ(x_1, x_2)) = 0
   POL(IF(x_1, x_2, x_3, x_4)) = x_1 + x_4
   POL(IF2(x_1, x_2, x_3, x_4)) = x_4
   POL(IF_MIN(x_1, x_2)) = x_2
   POL(IF_RM(x_1, x_2, x_3)) = x_3
   POL(LE(x_1, x_2)) = 0
   POL(MIN(x_1)) = x_1
   POL(MINS(x_1, x_2, x_3)) = x_3
   POL(RM(x_1, x_2)) = 0
   POL(add(x_1, x_2)) = 0
   POL(app(x_1, x_2)) = x_2
   POL(c(x_1)) = x_1
   POL(c1(x_1)) = x_1
   POL(c10(x_1)) = x_1
   POL(c10(x_1, x_2)) = x_1 + x_2
   POL(c11(x_1)) = x_1
   POL(c12(x_1)) = x_1
   POL(c19(x_1)) = x_1
   POL(c19(x_1, x_2)) = x_1 + x_2
   POL(c2(x_1)) = x_1
   POL(c20(x_1)) = x_1
   POL(c21(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c25(x_1)) = x_1
   POL(c25(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1)) = x_1
   POL(c26(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c27(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c28(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c29(x_1)) = x_1
   POL(c29(x_1, x_2)) = x_1 + x_2
   POL(c3(x_1)) = x_1
   POL(c30(x_1)) = x_1
   POL(c31(x_1)) = x_1
   POL(c4(x_1)) = x_1
   POL(c5(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(eq(x_1, x_2)) = 0
   POL(false) = 0
   POL(head(x_1)) = 0
   POL(if_min(x_1, x_2)) = [1] + x_2
   POL(if_rm(x_1, x_2, x_3)) = [1] + x_2 + x_3
   POL(le(x_1, x_2)) = 0
   POL(min(x_1)) = [1]
   POL(nil) = [1]
   POL(rm(x_1, x_2)) = 0
   POL(s(x_1)) = 0
   POL(tail(x_1)) = 0
   POL(true) = 0

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

(198)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1


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

(199) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil)))) by 
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))

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

(200)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1


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

(201) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1)) by 
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))

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

(202)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1


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

(203) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0))) by 
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c28(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)), APP(rm(head(nil), tail(nil)), x1), RM(head(nil), tail(nil)))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))

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

(204)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c28(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)), APP(rm(head(nil), tail(nil)), x1), RM(head(nil), tail(nil)))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1


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

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

(206)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c28(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)), APP(rm(head(nil), tail(nil)), x1))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c28_2


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

(207) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID))
Split RHS of tuples not part of any SCC
----------------------------------------

(208)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c7_1


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

(209) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF2(true, x0, x1, add(z0, z1)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0))) by 
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c28(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))), APP(rm(head(nil), tail(nil)), x1), RM(head(nil), tail(nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))

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

(210)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c28(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))), APP(rm(head(nil), tail(nil)), x1), RM(head(nil), tail(nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c28(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))), APP(rm(head(nil), tail(nil)), x1), RM(head(nil), tail(nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c7_1


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

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

(212)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c28(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))), APP(rm(head(nil), tail(nil)), x1))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c28(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))), APP(rm(head(nil), tail(nil)), x1))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c7_1, c28_2


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

(213) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID))
Split RHS of tuples not part of any SCC
----------------------------------------

(214)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c7_1, c9_1


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

(215) CdtKnowledgeProof (BOTH BOUNDS(ID, ID))
The following tuples could be moved from S to K by knowledge propagation:
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))

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

(216)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c7_1, c9_1


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

(217) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1)))) by 
   IF2(true, add(x0, x1), x2, nil) -> c28(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)), APP(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), RM(head(add(x0, x1)), tail(add(x0, x1))))
   IF2(true, add(x0, x1), x2, add(z0, z1)) -> c28(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(z0, app(z1, add(x0, nil)))), APP(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), RM(head(add(x0, x1)), tail(add(x0, x1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))

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

(218)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, x1), x2, nil) -> c28(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)), APP(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), RM(head(add(x0, x1)), tail(add(x0, x1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c7_1, c9_1


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

(219) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
We considered the (Usable) Rules:
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   app(nil, z0) -> z0
And the Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(APP(x_1, x_2)) = 0
   POL(EQ(x_1, x_2)) = 0
   POL(IF(x_1, x_2, x_3, x_4)) = x_1 + x_2 + x_4
   POL(IF2(x_1, x_2, x_3, x_4)) = x_4
   POL(IF_MIN(x_1, x_2)) = x_2
   POL(IF_RM(x_1, x_2, x_3)) = x_3
   POL(LE(x_1, x_2)) = 0
   POL(MIN(x_1)) = x_1
   POL(MINS(x_1, x_2, x_3)) = x_3
   POL(RM(x_1, x_2)) = 0
   POL(add(x_1, x_2)) = 0
   POL(app(x_1, x_2)) = x_2
   POL(c(x_1)) = x_1
   POL(c1(x_1)) = x_1
   POL(c10(x_1)) = x_1
   POL(c10(x_1, x_2)) = x_1 + x_2
   POL(c11(x_1)) = x_1
   POL(c12(x_1)) = x_1
   POL(c19(x_1)) = x_1
   POL(c19(x_1, x_2)) = x_1 + x_2
   POL(c2(x_1)) = x_1
   POL(c20(x_1)) = x_1
   POL(c21(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c25(x_1)) = x_1
   POL(c25(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1)) = x_1
   POL(c26(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c27(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c28(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c29(x_1)) = x_1
   POL(c29(x_1, x_2)) = x_1 + x_2
   POL(c3(x_1)) = x_1
   POL(c30(x_1)) = x_1
   POL(c31(x_1)) = x_1
   POL(c4(x_1)) = x_1
   POL(c5(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c7(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(c9(x_1)) = x_1
   POL(eq(x_1, x_2)) = 0
   POL(false) = 0
   POL(head(x_1)) = 0
   POL(if_min(x_1, x_2)) = [1] + x_2
   POL(if_rm(x_1, x_2, x_3)) = [1] + x_2 + x_3
   POL(le(x_1, x_2)) = 0
   POL(min(x_1)) = [1]
   POL(nil) = [1]
   POL(rm(x_1, x_2)) = 0
   POL(s(x_1)) = 0
   POL(tail(x_1)) = 0
   POL(true) = 0

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

(220)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c7_1, c9_1


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

(221) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1)))) by 
   IF2(true, add(x0, x1), x2, nil) -> c28(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)), APP(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), RM(head(add(x0, x1)), tail(add(x0, x1))))
   IF2(true, add(x0, x1), x2, add(z0, z1)) -> c28(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(z0, app(z1, add(head(add(x0, x1)), nil)))), APP(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), RM(head(add(x0, x1)), tail(add(x0, x1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))

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

(222)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, x1), x2, nil) -> c28(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)), APP(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), RM(head(add(x0, x1)), tail(add(x0, x1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c7_1, c9_1


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

(223) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
We considered the (Usable) Rules:
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   app(nil, z0) -> z0
And the Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(APP(x_1, x_2)) = 0
   POL(EQ(x_1, x_2)) = 0
   POL(IF(x_1, x_2, x_3, x_4)) = x_1 + x_4
   POL(IF2(x_1, x_2, x_3, x_4)) = x_2 + x_4
   POL(IF_MIN(x_1, x_2)) = x_2
   POL(IF_RM(x_1, x_2, x_3)) = x_3
   POL(LE(x_1, x_2)) = 0
   POL(MIN(x_1)) = x_1
   POL(MINS(x_1, x_2, x_3)) = x_3
   POL(RM(x_1, x_2)) = 0
   POL(add(x_1, x_2)) = 0
   POL(app(x_1, x_2)) = x_2
   POL(c(x_1)) = x_1
   POL(c1(x_1)) = x_1
   POL(c10(x_1)) = x_1
   POL(c10(x_1, x_2)) = x_1 + x_2
   POL(c11(x_1)) = x_1
   POL(c12(x_1)) = x_1
   POL(c19(x_1)) = x_1
   POL(c19(x_1, x_2)) = x_1 + x_2
   POL(c2(x_1)) = x_1
   POL(c20(x_1)) = x_1
   POL(c21(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c25(x_1)) = x_1
   POL(c25(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1)) = x_1
   POL(c26(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c27(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c28(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c29(x_1)) = x_1
   POL(c29(x_1, x_2)) = x_1 + x_2
   POL(c3(x_1)) = x_1
   POL(c30(x_1)) = x_1
   POL(c31(x_1)) = x_1
   POL(c4(x_1)) = x_1
   POL(c5(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c7(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(c9(x_1)) = x_1
   POL(eq(x_1, x_2)) = 0
   POL(false) = 0
   POL(head(x_1)) = 0
   POL(if_min(x_1, x_2)) = [1] + x_2
   POL(if_rm(x_1, x_2, x_3)) = [1] + x_2 + x_3
   POL(le(x_1, x_2)) = 0
   POL(min(x_1)) = [1]
   POL(nil) = [1]
   POL(rm(x_1, x_2)) = 0
   POL(s(x_1)) = 0
   POL(tail(x_1)) = 0
   POL(true) = 0

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

(224)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c28_3, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c7_1, c9_1


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

(225) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF2(true, add(z0, z1), x1, x2) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1)))) by 
   IF2(true, add(x0, x1), x2, nil) -> c28(MINS(app(rm(x0, tail(add(x0, x1))), x2), nil, add(head(add(x0, x1)), nil)), APP(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), RM(head(add(x0, x1)), tail(add(x0, x1))))
   IF2(true, add(x0, x1), x2, add(z0, z1)) -> c28(MINS(app(rm(x0, tail(add(x0, x1))), x2), nil, add(z0, app(z1, add(head(add(x0, x1)), nil)))), APP(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), RM(head(add(x0, x1)), tail(add(x0, x1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))

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

(226)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, x1), x2, nil) -> c28(MINS(app(rm(x0, tail(add(x0, x1))), x2), nil, add(head(add(x0, x1)), nil)), APP(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), RM(head(add(x0, x1)), tail(add(x0, x1))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c28_3, c7_1, c9_1


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

(227) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
We considered the (Usable) Rules:
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   app(nil, z0) -> z0
And the Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(APP(x_1, x_2)) = 0
   POL(EQ(x_1, x_2)) = 0
   POL(IF(x_1, x_2, x_3, x_4)) = x_1 + x_4
   POL(IF2(x_1, x_2, x_3, x_4)) = x_2 + x_4
   POL(IF_MIN(x_1, x_2)) = x_2
   POL(IF_RM(x_1, x_2, x_3)) = x_3
   POL(LE(x_1, x_2)) = 0
   POL(MIN(x_1)) = x_1
   POL(MINS(x_1, x_2, x_3)) = x_3
   POL(RM(x_1, x_2)) = 0
   POL(add(x_1, x_2)) = 0
   POL(app(x_1, x_2)) = x_2
   POL(c(x_1)) = x_1
   POL(c1(x_1)) = x_1
   POL(c10(x_1)) = x_1
   POL(c10(x_1, x_2)) = x_1 + x_2
   POL(c11(x_1)) = x_1
   POL(c12(x_1)) = x_1
   POL(c19(x_1)) = x_1
   POL(c19(x_1, x_2)) = x_1 + x_2
   POL(c2(x_1)) = x_1
   POL(c20(x_1)) = x_1
   POL(c21(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c25(x_1)) = x_1
   POL(c25(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1)) = x_1
   POL(c26(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c27(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c28(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c29(x_1)) = x_1
   POL(c29(x_1, x_2)) = x_1 + x_2
   POL(c3(x_1)) = x_1
   POL(c30(x_1)) = x_1
   POL(c31(x_1)) = x_1
   POL(c4(x_1)) = x_1
   POL(c5(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c7(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(c9(x_1)) = x_1
   POL(eq(x_1, x_2)) = 0
   POL(false) = 0
   POL(head(x_1)) = 0
   POL(if_min(x_1, x_2)) = [1] + x_2
   POL(if_rm(x_1, x_2, x_3)) = [1] + x_2 + x_3
   POL(le(x_1, x_2)) = 0
   POL(min(x_1)) = [1]
   POL(nil) = [1]
   POL(rm(x_1, x_2)) = 0
   POL(s(x_1)) = 0
   POL(tail(x_1)) = 0
   POL(true) = 0

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

(228)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c28_3, c7_1, c9_1


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

(229) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil)))) by 
   IF2(true, nil, x0, nil) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c1(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))

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

(230)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c1(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c1_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c28_3, c7_1, c9_1


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

(231) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1)) by 
   IF2(true, nil, x0, x1) -> c1(APP(rm(head(nil), nil), x0))

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

(232)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c1(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c1(APP(rm(head(nil), nil), x0))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c28_3, c7_1, c9_1, c1_1


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

(233) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF2(true, x0, x1, add(z0, z1)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(z0, app(z1, add(head(x0), nil)))), APP(add(z0, z1), add(head(x0), nil))) by 
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, nil, x1, add(x2, x3)) -> c29(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))), APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))

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

(234)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c1(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c1(APP(rm(head(nil), nil), x0))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, nil, x1, add(x2, x3)) -> c29(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))), APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, nil, x1, add(x2, x3)) -> c29(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))), APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c28_3, c7_1, c9_1, c1_1


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

(235) CdtGraphSplitRhsProof (BOTH BOUNDS(ID, ID))
Split RHS of tuples not part of any SCC
----------------------------------------

(236)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c1(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c1(APP(rm(head(nil), nil), x0))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c28_3, c7_1, c9_1, c1_1, c13_1


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

(237) CdtKnowledgeProof (BOTH BOUNDS(ID, ID))
The following tuples could be moved from S to K by knowledge propagation:
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))

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

(238)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c1(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c1(APP(rm(head(nil), nil), x0))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c28_3, c7_1, c9_1, c1_1, c13_1


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

(239) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
We considered the (Usable) Rules:
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   eq(0, 0) -> true
And the Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c1(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c1(APP(rm(head(nil), nil), x0))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(APP(x_1, x_2)) = 0
   POL(EQ(x_1, x_2)) = 0
   POL(IF(x_1, x_2, x_3, x_4)) = x_1
   POL(IF2(x_1, x_2, x_3, x_4)) = x_1
   POL(IF_MIN(x_1, x_2)) = x_2
   POL(IF_RM(x_1, x_2, x_3)) = x_3
   POL(LE(x_1, x_2)) = 0
   POL(MIN(x_1)) = x_1
   POL(MINS(x_1, x_2, x_3)) = [1]
   POL(RM(x_1, x_2)) = 0
   POL(add(x_1, x_2)) = 0
   POL(app(x_1, x_2)) = [1]
   POL(c(x_1)) = x_1
   POL(c1(x_1)) = x_1
   POL(c10(x_1)) = x_1
   POL(c10(x_1, x_2)) = x_1 + x_2
   POL(c11(x_1)) = x_1
   POL(c12(x_1)) = x_1
   POL(c13(x_1)) = x_1
   POL(c19(x_1)) = x_1
   POL(c19(x_1, x_2)) = x_1 + x_2
   POL(c2(x_1)) = x_1
   POL(c20(x_1)) = x_1
   POL(c21(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c25(x_1)) = x_1
   POL(c25(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1)) = x_1
   POL(c26(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c27(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c28(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c29(x_1)) = x_1
   POL(c29(x_1, x_2)) = x_1 + x_2
   POL(c3(x_1)) = x_1
   POL(c30(x_1)) = x_1
   POL(c31(x_1)) = x_1
   POL(c4(x_1)) = x_1
   POL(c5(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c7(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(c9(x_1)) = x_1
   POL(eq(x_1, x_2)) = [1]
   POL(false) = [1]
   POL(head(x_1)) = 0
   POL(if_min(x_1, x_2)) = [1] + x_2
   POL(if_rm(x_1, x_2, x_3)) = [1] + x_2 + x_3
   POL(le(x_1, x_2)) = 0
   POL(min(x_1)) = [1]
   POL(nil) = 0
   POL(rm(x_1, x_2)) = 0
   POL(s(x_1)) = 0
   POL(tail(x_1)) = 0
   POL(true) = [1]

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

(240)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c1(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c1(APP(rm(head(nil), nil), x0))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c28_3, c7_1, c9_1, c1_1, c13_1


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

(241) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, app(x2, add(z0, nil))), APP(x2, add(head(add(z0, z1)), nil))) by 
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)), APP(nil, add(head(add(x0, x1)), nil)))
   IF2(true, add(x0, x1), x2, add(z0, z1)) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(z0, app(z1, add(x0, nil)))), APP(add(z0, z1), add(head(add(x0, x1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))

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

(242)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c1(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c1(APP(rm(head(nil), nil), x0))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)), APP(nil, add(head(add(x0, x1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)), APP(nil, add(head(add(x0, x1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c28_3, c7_1, c9_1, c1_1, c13_1


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

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

(244)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c1(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c1(APP(rm(head(nil), nil), x0))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c28_3, c7_1, c9_1, c1_1, c13_1


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

(245) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
We considered the (Usable) Rules:
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   app(nil, z0) -> z0
And the Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c1(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c1(APP(rm(head(nil), nil), x0))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(APP(x_1, x_2)) = 0
   POL(EQ(x_1, x_2)) = 0
   POL(IF(x_1, x_2, x_3, x_4)) = x_1 + x_2 + x_4
   POL(IF2(x_1, x_2, x_3, x_4)) = x_2 + x_4
   POL(IF_MIN(x_1, x_2)) = x_2
   POL(IF_RM(x_1, x_2, x_3)) = x_3
   POL(LE(x_1, x_2)) = 0
   POL(MIN(x_1)) = x_1
   POL(MINS(x_1, x_2, x_3)) = x_3
   POL(RM(x_1, x_2)) = 0
   POL(add(x_1, x_2)) = 0
   POL(app(x_1, x_2)) = x_2
   POL(c(x_1)) = x_1
   POL(c1(x_1)) = x_1
   POL(c10(x_1)) = x_1
   POL(c10(x_1, x_2)) = x_1 + x_2
   POL(c11(x_1)) = x_1
   POL(c12(x_1)) = x_1
   POL(c13(x_1)) = x_1
   POL(c19(x_1)) = x_1
   POL(c19(x_1, x_2)) = x_1 + x_2
   POL(c2(x_1)) = x_1
   POL(c20(x_1)) = x_1
   POL(c21(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c25(x_1)) = x_1
   POL(c25(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1)) = x_1
   POL(c26(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c27(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c28(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c29(x_1)) = x_1
   POL(c29(x_1, x_2)) = x_1 + x_2
   POL(c3(x_1)) = x_1
   POL(c30(x_1)) = x_1
   POL(c31(x_1)) = x_1
   POL(c4(x_1)) = x_1
   POL(c5(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c7(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(c9(x_1)) = x_1
   POL(eq(x_1, x_2)) = 0
   POL(false) = 0
   POL(head(x_1)) = 0
   POL(if_min(x_1, x_2)) = [1] + x_2
   POL(if_rm(x_1, x_2, x_3)) = [1] + x_2 + x_3
   POL(le(x_1, x_2)) = 0
   POL(min(x_1)) = [1]
   POL(nil) = [1]
   POL(rm(x_1, x_2)) = 0
   POL(s(x_1)) = 0
   POL(tail(x_1)) = 0
   POL(true) = 0

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

(246)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c1(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c1(APP(rm(head(nil), nil), x0))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c28_3, c7_1, c9_1, c1_1, c13_1


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

(247) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil))) by 
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)), APP(nil, add(head(add(x0, x1)), nil)))
   IF2(true, add(x0, x1), x2, add(z0, z1)) -> c29(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(z0, app(z1, add(head(add(x0, x1)), nil)))), APP(add(z0, z1), add(head(add(x0, x1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, nil), x2, x3) -> c29(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(x3, add(head(add(x0, nil)), nil)))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c29(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(x3, add(head(add(x0, add(z1, z2))), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(x3, add(head(add(z0, z1)), nil)))

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

(248)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c1(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c1(APP(rm(head(nil), nil), x0))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)), APP(nil, add(head(add(x0, x1)), nil)))
   IF2(true, add(x0, nil), x2, x3) -> c29(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(x3, add(head(add(x0, nil)), nil)))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c29(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(x3, add(head(add(x0, add(z1, z2))), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(x3, add(head(add(z0, z1)), nil)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)), APP(nil, add(head(add(x0, x1)), nil)))
   IF2(true, add(x0, nil), x2, x3) -> c29(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(x3, add(head(add(x0, nil)), nil)))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c29(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(x3, add(head(add(x0, add(z1, z2))), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(x3, add(head(add(z0, z1)), nil)))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c28_3, c7_1, c9_1, c1_1, c13_1


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

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

(250)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c1(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c1(APP(rm(head(nil), nil), x0))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
   IF2(true, add(x0, nil), x2, x3) -> c29(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(x3, add(head(add(x0, nil)), nil)))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c29(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(x3, add(head(add(x0, add(z1, z2))), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, nil), x2, x3) -> c29(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(x3, add(head(add(x0, nil)), nil)))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c29(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(x3, add(head(add(x0, add(z1, z2))), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c28_3, c7_1, c9_1, c1_1, c13_1


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

(251) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)))
We considered the (Usable) Rules:
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   app(nil, z0) -> z0
And the Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c1(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c1(APP(rm(head(nil), nil), x0))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
   IF2(true, add(x0, nil), x2, x3) -> c29(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(x3, add(head(add(x0, nil)), nil)))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c29(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(x3, add(head(add(x0, add(z1, z2))), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(APP(x_1, x_2)) = 0
   POL(EQ(x_1, x_2)) = 0
   POL(IF(x_1, x_2, x_3, x_4)) = x_1 + x_2 + x_4
   POL(IF2(x_1, x_2, x_3, x_4)) = x_4
   POL(IF_MIN(x_1, x_2)) = x_2
   POL(IF_RM(x_1, x_2, x_3)) = x_3
   POL(LE(x_1, x_2)) = 0
   POL(MIN(x_1)) = x_1
   POL(MINS(x_1, x_2, x_3)) = x_3
   POL(RM(x_1, x_2)) = 0
   POL(add(x_1, x_2)) = 0
   POL(app(x_1, x_2)) = x_2
   POL(c(x_1)) = x_1
   POL(c1(x_1)) = x_1
   POL(c10(x_1)) = x_1
   POL(c10(x_1, x_2)) = x_1 + x_2
   POL(c11(x_1)) = x_1
   POL(c12(x_1)) = x_1
   POL(c13(x_1)) = x_1
   POL(c19(x_1)) = x_1
   POL(c19(x_1, x_2)) = x_1 + x_2
   POL(c2(x_1)) = x_1
   POL(c20(x_1)) = x_1
   POL(c21(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c25(x_1)) = x_1
   POL(c25(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1)) = x_1
   POL(c26(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c27(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c28(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c29(x_1)) = x_1
   POL(c29(x_1, x_2)) = x_1 + x_2
   POL(c3(x_1)) = x_1
   POL(c30(x_1)) = x_1
   POL(c31(x_1)) = x_1
   POL(c4(x_1)) = x_1
   POL(c5(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c7(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(c9(x_1)) = x_1
   POL(eq(x_1, x_2)) = 0
   POL(false) = 0
   POL(head(x_1)) = 0
   POL(if_min(x_1, x_2)) = [1] + x_2
   POL(if_rm(x_1, x_2, x_3)) = [1] + x_2 + x_3
   POL(le(x_1, x_2)) = 0
   POL(min(x_1)) = [1]
   POL(nil) = [1]
   POL(rm(x_1, x_2)) = 0
   POL(s(x_1)) = 0
   POL(tail(x_1)) = 0
   POL(true) = 0

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

(252)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c1(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c1(APP(rm(head(nil), nil), x0))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
   IF2(true, add(x0, nil), x2, x3) -> c29(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(x3, add(head(add(x0, nil)), nil)))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c29(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(x3, add(head(add(x0, add(z1, z2))), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, nil), x2, x3) -> c29(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(x3, add(head(add(x0, nil)), nil)))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c29(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(x3, add(head(add(x0, add(z1, z2))), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(x3, add(head(add(z0, z1)), nil)))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c29_2, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c28_3, c7_1, c9_1, c1_1, c13_1


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

(253) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF2(true, add(z0, z1), x1, x2) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, app(x2, add(head(add(z0, z1)), nil))), APP(x2, add(head(add(z0, z1)), nil))) by 
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(x0, tail(add(x0, x1))), x2), nil, add(head(add(x0, x1)), nil)), APP(nil, add(head(add(x0, x1)), nil)))
   IF2(true, add(x0, x1), x2, add(z0, z1)) -> c29(MINS(app(rm(x0, tail(add(x0, x1))), x2), nil, add(z0, app(z1, add(head(add(x0, x1)), nil)))), APP(add(z0, z1), add(head(add(x0, x1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(x3, add(head(add(z0, z1)), nil)))

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

(254)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c1(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c1(APP(rm(head(nil), nil), x0))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
   IF2(true, add(x0, nil), x2, x3) -> c29(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(x3, add(head(add(x0, nil)), nil)))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c29(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(x3, add(head(add(x0, add(z1, z2))), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(x0, tail(add(x0, x1))), x2), nil, add(head(add(x0, x1)), nil)), APP(nil, add(head(add(x0, x1)), nil)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, nil), x2, x3) -> c29(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(x3, add(head(add(x0, nil)), nil)))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c29(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(x3, add(head(add(x0, add(z1, z2))), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(x0, tail(add(x0, x1))), x2), nil, add(head(add(x0, x1)), nil)), APP(nil, add(head(add(x0, x1)), nil)))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c28_3, c7_1, c9_1, c1_1, c29_2, c13_1


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

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

(256)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c1(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c1(APP(rm(head(nil), nil), x0))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
   IF2(true, add(x0, nil), x2, x3) -> c29(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(x3, add(head(add(x0, nil)), nil)))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c29(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(x3, add(head(add(x0, add(z1, z2))), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(x0, tail(add(x0, x1))), x2), nil, add(head(add(x0, x1)), nil)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, nil), x2, x3) -> c29(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(x3, add(head(add(x0, nil)), nil)))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c29(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(x3, add(head(add(x0, add(z1, z2))), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(x0, tail(add(x0, x1))), x2), nil, add(head(add(x0, x1)), nil)))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c28_3, c7_1, c9_1, c1_1, c29_2, c13_1


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

(257) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(x0, tail(add(x0, x1))), x2), nil, add(head(add(x0, x1)), nil)))
We considered the (Usable) Rules:
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   app(nil, z0) -> z0
And the Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c1(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c1(APP(rm(head(nil), nil), x0))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
   IF2(true, add(x0, nil), x2, x3) -> c29(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(x3, add(head(add(x0, nil)), nil)))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c29(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(x3, add(head(add(x0, add(z1, z2))), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(x0, tail(add(x0, x1))), x2), nil, add(head(add(x0, x1)), nil)))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(APP(x_1, x_2)) = 0
   POL(EQ(x_1, x_2)) = 0
   POL(IF(x_1, x_2, x_3, x_4)) = x_1 + x_2 + x_4
   POL(IF2(x_1, x_2, x_3, x_4)) = x_4
   POL(IF_MIN(x_1, x_2)) = x_2
   POL(IF_RM(x_1, x_2, x_3)) = x_3
   POL(LE(x_1, x_2)) = 0
   POL(MIN(x_1)) = x_1
   POL(MINS(x_1, x_2, x_3)) = x_3
   POL(RM(x_1, x_2)) = 0
   POL(add(x_1, x_2)) = 0
   POL(app(x_1, x_2)) = x_2
   POL(c(x_1)) = x_1
   POL(c1(x_1)) = x_1
   POL(c10(x_1)) = x_1
   POL(c10(x_1, x_2)) = x_1 + x_2
   POL(c11(x_1)) = x_1
   POL(c12(x_1)) = x_1
   POL(c13(x_1)) = x_1
   POL(c19(x_1)) = x_1
   POL(c19(x_1, x_2)) = x_1 + x_2
   POL(c2(x_1)) = x_1
   POL(c20(x_1)) = x_1
   POL(c21(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c25(x_1)) = x_1
   POL(c25(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1)) = x_1
   POL(c26(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c27(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c28(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c29(x_1)) = x_1
   POL(c29(x_1, x_2)) = x_1 + x_2
   POL(c3(x_1)) = x_1
   POL(c30(x_1)) = x_1
   POL(c31(x_1)) = x_1
   POL(c4(x_1)) = x_1
   POL(c5(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c7(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(c9(x_1)) = x_1
   POL(eq(x_1, x_2)) = 0
   POL(false) = 0
   POL(head(x_1)) = 0
   POL(if_min(x_1, x_2)) = [1] + x_2
   POL(if_rm(x_1, x_2, x_3)) = [1] + x_2 + x_3
   POL(le(x_1, x_2)) = 0
   POL(min(x_1)) = [1]
   POL(nil) = [1]
   POL(rm(x_1, x_2)) = 0
   POL(s(x_1)) = 0
   POL(tail(x_1)) = 0
   POL(true) = 0

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

(258)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c1(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c1(APP(rm(head(nil), nil), x0))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
   IF2(true, add(x0, nil), x2, x3) -> c29(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(x3, add(head(add(x0, nil)), nil)))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c29(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(x3, add(head(add(x0, add(z1, z2))), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(x0, tail(add(x0, x1))), x2), nil, add(head(add(x0, x1)), nil)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, nil), x2, x3) -> c29(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(x3, add(head(add(x0, nil)), nil)))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c29(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(x3, add(head(add(x0, add(z1, z2))), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(x3, add(head(add(z0, z1)), nil)))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(x0, tail(add(x0, x1))), x2), nil, add(head(add(x0, x1)), nil)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c29_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c28_3, c7_1, c9_1, c1_1, c29_2, c13_1


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

(259) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil))) by 
   IF2(true, add(z0, z1), x1, nil) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)))
   IF2(true, add(z0, z1), x1, nil) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)))
   IF2(true, nil, x1, nil) -> c29(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, add(z0, z1), x1, nil) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)))

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

(260)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c1(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c1(APP(rm(head(nil), nil), x0))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
   IF2(true, add(x0, nil), x2, x3) -> c29(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(x3, add(head(add(x0, nil)), nil)))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c29(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(x3, add(head(add(x0, add(z1, z2))), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(x0, tail(add(x0, x1))), x2), nil, add(head(add(x0, x1)), nil)))
   IF2(true, nil, x1, nil) -> c29(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, nil), x2, x3) -> c29(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(x3, add(head(add(x0, nil)), nil)))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c29(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(x3, add(head(add(x0, add(z1, z2))), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(x3, add(head(add(z0, z1)), nil)))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(x0, tail(add(x0, x1))), x2), nil, add(head(add(x0, x1)), nil)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c28_3, c7_1, c9_1, c1_1, c29_2, c29_1, c13_1


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

(261) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil)))) by 
   IF2(true, nil, x0, nil) -> c2(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c2(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c2(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))

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

(262)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c1(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c1(APP(rm(head(nil), nil), x0))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
   IF2(true, add(x0, nil), x2, x3) -> c29(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(x3, add(head(add(x0, nil)), nil)))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c29(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(x3, add(head(add(x0, add(z1, z2))), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(x0, tail(add(x0, x1))), x2), nil, add(head(add(x0, x1)), nil)))
   IF2(true, nil, x1, nil) -> c29(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x0, nil) -> c2(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c2(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c2(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, nil), x2, x3) -> c29(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(x3, add(head(add(x0, nil)), nil)))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c29(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(x3, add(head(add(x0, add(z1, z2))), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(x3, add(head(add(z0, z1)), nil)))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(x0, tail(add(x0, x1))), x2), nil, add(head(add(x0, x1)), nil)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c28_3, c7_1, c9_1, c1_1, c29_2, c29_1, c13_1


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

(263) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF2(false, add(z0, z1), x1, x2) -> c30(MINS(tail(add(z0, z1)), add(z0, x1), x2)) by 
   IF2(false, add(z0, z1), x2, x3) -> c30(MINS(z1, add(z0, x2), x3))

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

(264)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c1(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c1(APP(rm(head(nil), nil), x0))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
   IF2(true, add(x0, nil), x2, x3) -> c29(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(x3, add(head(add(x0, nil)), nil)))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c29(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(x3, add(head(add(x0, add(z1, z2))), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(x0, tail(add(x0, x1))), x2), nil, add(head(add(x0, x1)), nil)))
   IF2(true, nil, x1, nil) -> c29(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x0, nil) -> c2(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c2(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c2(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(false, add(z0, z1), x2, x3) -> c30(MINS(z1, add(z0, x2), x3))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, nil), x2, x3) -> c29(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(x3, add(head(add(x0, nil)), nil)))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c29(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(x3, add(head(add(x0, add(z1, z2))), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x2, x3) -> c30(MINS(z1, add(z0, x2), x3))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(x0, tail(add(x0, x1))), x2), nil, add(head(add(x0, x1)), nil)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c2_1, c30_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c28_3, c7_1, c9_1, c1_1, c29_2, c29_1, c13_1


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

(265) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF2(false, add(z0, z1), x1, x2) -> c30(MINS(z1, add(head(add(z0, z1)), x1), x2)) by 
   IF2(false, add(z0, z1), x2, x3) -> c30(MINS(z1, add(z0, x2), x3))

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

(266)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c1(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c1(APP(rm(head(nil), nil), x0))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
   IF2(true, add(x0, nil), x2, x3) -> c29(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(x3, add(head(add(x0, nil)), nil)))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c29(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(x3, add(head(add(x0, add(z1, z2))), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(x0, tail(add(x0, x1))), x2), nil, add(head(add(x0, x1)), nil)))
   IF2(true, nil, x1, nil) -> c29(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x0, nil) -> c2(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c2(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c2(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(false, add(z0, z1), x2, x3) -> c30(MINS(z1, add(z0, x2), x3))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, nil), x2, x3) -> c29(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(x3, add(head(add(x0, nil)), nil)))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c29(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(x3, add(head(add(x0, add(z1, z2))), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x2, x3) -> c30(MINS(z1, add(z0, x2), x3))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(x0, tail(add(x0, x1))), x2), nil, add(head(add(x0, x1)), nil)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c2_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c28_3, c7_1, c9_1, c1_1, c29_2, c29_1, c13_1, c30_1


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

(267) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF2(false, add(z0, z1), x1, x2) -> c31(MINS(tail(add(z0, z1)), add(z0, x1), x2)) by 
   IF2(false, add(z0, z1), x2, x3) -> c31(MINS(z1, add(z0, x2), x3))

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

(268)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c1(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c1(APP(rm(head(nil), nil), x0))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
   IF2(true, add(x0, nil), x2, x3) -> c29(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(x3, add(head(add(x0, nil)), nil)))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c29(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(x3, add(head(add(x0, add(z1, z2))), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(x0, tail(add(x0, x1))), x2), nil, add(head(add(x0, x1)), nil)))
   IF2(true, nil, x1, nil) -> c29(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x0, nil) -> c2(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c2(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c2(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(false, add(z0, z1), x2, x3) -> c30(MINS(z1, add(z0, x2), x3))
   IF2(false, add(z0, z1), x2, x3) -> c31(MINS(z1, add(z0, x2), x3))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, nil), x2, x3) -> c29(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(x3, add(head(add(x0, nil)), nil)))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c29(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(x3, add(head(add(x0, add(z1, z2))), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x2, x3) -> c30(MINS(z1, add(z0, x2), x3))
   IF2(false, add(z0, z1), x2, x3) -> c31(MINS(z1, add(z0, x2), x3))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(x0, tail(add(x0, x1))), x2), nil, add(head(add(x0, x1)), nil)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c2_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c28_3, c7_1, c9_1, c1_1, c29_2, c29_1, c13_1, c30_1


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

(269) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, nil), x2, x3) -> c29(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(x3, add(head(add(x0, nil)), nil)))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c29(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(x3, add(head(add(x0, add(z1, z2))), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(x3, add(head(add(z0, z1)), nil)))
We considered the (Usable) Rules:
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   app(nil, z0) -> z0
   rm(z0, nil) -> nil
   tail(nil) -> nil
   tail(add(z0, z1)) -> z1
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
And the Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c1(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c1(APP(rm(head(nil), nil), x0))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
   IF2(true, add(x0, nil), x2, x3) -> c29(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(x3, add(head(add(x0, nil)), nil)))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c29(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(x3, add(head(add(x0, add(z1, z2))), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(x0, tail(add(x0, x1))), x2), nil, add(head(add(x0, x1)), nil)))
   IF2(true, nil, x1, nil) -> c29(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x0, nil) -> c2(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c2(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c2(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(false, add(z0, z1), x2, x3) -> c30(MINS(z1, add(z0, x2), x3))
   IF2(false, add(z0, z1), x2, x3) -> c31(MINS(z1, add(z0, x2), x3))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(APP(x_1, x_2)) = 0
   POL(EQ(x_1, x_2)) = 0
   POL(IF(x_1, x_2, x_3, x_4)) = x_1 + x_2 + x_3
   POL(IF2(x_1, x_2, x_3, x_4)) = x_2 + x_3
   POL(IF_MIN(x_1, x_2)) = 0
   POL(IF_RM(x_1, x_2, x_3)) = 0
   POL(LE(x_1, x_2)) = 0
   POL(MIN(x_1)) = 0
   POL(MINS(x_1, x_2, x_3)) = x_1 + x_2
   POL(RM(x_1, x_2)) = 0
   POL(add(x_1, x_2)) = [1] + x_2
   POL(app(x_1, x_2)) = x_1 + x_2
   POL(c(x_1)) = x_1
   POL(c1(x_1)) = x_1
   POL(c10(x_1)) = x_1
   POL(c10(x_1, x_2)) = x_1 + x_2
   POL(c11(x_1)) = x_1
   POL(c12(x_1)) = x_1
   POL(c13(x_1)) = x_1
   POL(c19(x_1)) = x_1
   POL(c19(x_1, x_2)) = x_1 + x_2
   POL(c2(x_1)) = x_1
   POL(c20(x_1)) = x_1
   POL(c21(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c25(x_1)) = x_1
   POL(c25(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1)) = x_1
   POL(c26(x_1, x_2)) = x_1 + x_2
   POL(c26(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c27(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c28(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c29(x_1)) = x_1
   POL(c29(x_1, x_2)) = x_1 + x_2
   POL(c3(x_1)) = x_1
   POL(c30(x_1)) = x_1
   POL(c31(x_1)) = x_1
   POL(c4(x_1)) = x_1
   POL(c5(x_1)) = x_1
   POL(c6(x_1)) = x_1
   POL(c7(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(c9(x_1)) = x_1
   POL(eq(x_1, x_2)) = 0
   POL(false) = 0
   POL(head(x_1)) = 0
   POL(if_min(x_1, x_2)) = [1] + x_2
   POL(if_rm(x_1, x_2, x_3)) = x_3
   POL(le(x_1, x_2)) = 0
   POL(min(x_1)) = [1]
   POL(nil) = 0
   POL(rm(x_1, x_2)) = x_2
   POL(s(x_1)) = 0
   POL(tail(x_1)) = x_1
   POL(true) = 0

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

(270)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c1(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c1(APP(rm(head(nil), nil), x0))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
   IF2(true, add(x0, nil), x2, x3) -> c29(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(x3, add(head(add(x0, nil)), nil)))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c29(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(x3, add(head(add(x0, add(z1, z2))), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(x0, tail(add(x0, x1))), x2), nil, add(head(add(x0, x1)), nil)))
   IF2(true, nil, x1, nil) -> c29(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x0, nil) -> c2(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c2(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c2(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(false, add(z0, z1), x2, x3) -> c30(MINS(z1, add(z0, x2), x3))
   IF2(false, add(z0, z1), x2, x3) -> c31(MINS(z1, add(z0, x2), x3))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x2, x3) -> c30(MINS(z1, add(z0, x2), x3))
   IF2(false, add(z0, z1), x2, x3) -> c31(MINS(z1, add(z0, x2), x3))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(x0, tail(add(x0, x1))), x2), nil, add(head(add(x0, x1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, nil), x2, x3) -> c29(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(x3, add(head(add(x0, nil)), nil)))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c29(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(x3, add(head(add(x0, add(z1, z2))), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(x3, add(head(add(z0, z1)), nil)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c2_1, c31_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c28_3, c7_1, c9_1, c1_1, c29_2, c29_1, c13_1, c30_1


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

(271) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF2(false, add(z0, z1), x1, x2) -> c31(MINS(z1, add(head(add(z0, z1)), x1), x2)) by 
   IF2(false, add(z0, z1), x2, x3) -> c31(MINS(z1, add(z0, x2), x3))

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

(272)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   eq(0, 0) -> true
   eq(0, s(z0)) -> false
   eq(s(z0), 0) -> false
   eq(s(z0), s(z1)) -> eq(z0, z1)
   head(add(z0, z1)) -> z0
   min(add(z0, nil)) -> z0
   min(add(z0, add(z1, z2))) -> if_min(le(z0, z1), add(z0, add(z1, z2)))
   if_min(true, add(z0, add(z1, z2))) -> min(add(z0, z2))
   if_min(false, add(z0, add(z1, z2))) -> min(add(z1, z2))
   le(0, z0) -> true
   le(s(z0), 0) -> false
   le(s(z0), s(z1)) -> le(z0, z1)
   app(nil, z0) -> z0
   app(add(z0, z1), z2) -> add(z0, app(z1, z2))
   rm(z0, nil) -> nil
   rm(z0, add(z1, z2)) -> if_rm(eq(z0, z1), z0, add(z1, z2))
   tail(add(z0, z1)) -> z1
   tail(nil) -> nil
   if_rm(true, z0, add(z1, z2)) -> rm(z0, z2)
   if_rm(false, z0, add(z1, z2)) -> add(z1, rm(z0, z2))
Tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c4(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c4(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c(APP(rm(head(nil), nil), x0))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, nil) -> c7(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x1, nil) -> c7(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x0, nil) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c1(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c1(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(true, nil, x0, x1) -> c1(APP(rm(head(nil), nil), x0))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
   IF2(true, add(x0, nil), x2, x3) -> c29(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(x3, add(head(add(x0, nil)), nil)))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c29(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(x3, add(head(add(x0, add(z1, z2))), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(x0, tail(add(x0, x1))), x2), nil, add(head(add(x0, x1)), nil)))
   IF2(true, nil, x1, nil) -> c29(MINS(app(rm(head(nil), nil), x1), nil, add(head(nil), nil)))
   IF2(true, nil, x0, nil) -> c2(MINS(app(rm(head(nil), nil), x0), nil, add(head(nil), nil)))
   IF2(true, nil, x0, add(z0, z1)) -> c2(MINS(app(rm(head(nil), nil), x0), nil, add(z0, app(z1, add(head(nil), nil)))))
   IF2(true, nil, x0, x1) -> c2(MINS(app(nil, x0), nil, app(x1, add(head(nil), nil))))
   IF2(false, add(z0, z1), x2, x3) -> c30(MINS(z1, add(z0, x2), x3))
   IF2(false, add(z0, z1), x2, x3) -> c31(MINS(z1, add(z0, x2), x3))
S tuples:
   EQ(s(z0), s(z1)) -> c3(EQ(z0, z1))
   LE(s(z0), s(z1)) -> c6(LE(z0, z1))
   APP(add(z0, z1), z2) -> c8(APP(z1, z2))
   IF_MIN(true, add(z0, add(z1, z2))) -> c11(MIN(add(z0, z2)))
   IF_MIN(false, add(z0, add(z1, z2))) -> c12(MIN(add(z1, z2)))
   IF_RM(true, z0, add(z1, z2)) -> c20(RM(z0, z2))
   IF_RM(false, z0, add(z1, z2)) -> c21(RM(z0, z2))
   MIN(add(0, add(z0, x2))) -> c10(IF_MIN(true, add(0, add(z0, x2))))
   MIN(add(s(z0), add(0, x2))) -> c10(IF_MIN(false, add(s(z0), add(0, x2))))
   RM(0, add(0, x2)) -> c19(IF_RM(true, 0, add(0, x2)))
   RM(0, add(s(z0), x2)) -> c19(IF_RM(false, 0, add(s(z0), x2)))
   RM(s(z0), add(0, x2)) -> c19(IF_RM(false, s(z0), add(0, x2)))
   MINS(add(z0, z1), x1, x2) -> c23(IF(false, add(z0, z1), x1, x2))
   MIN(add(s(0), add(s(z0), x2))) -> c10(IF_MIN(true, add(s(0), add(s(z0), x2))), LE(s(0), s(z0)))
   MIN(add(s(s(z0)), add(s(0), x2))) -> c10(IF_MIN(false, add(s(s(z0)), add(s(0), x2))), LE(s(s(z0)), s(0)))
   MIN(add(s(s(z0)), add(s(s(z1)), x2))) -> c10(IF_MIN(le(z0, z1), add(s(s(z0)), add(s(s(z1)), x2))), LE(s(s(z0)), s(s(z1))))
   MIN(add(s(x0), add(s(x1), x2))) -> c10(LE(s(x0), s(x1)))
   RM(s(0), add(s(0), x2)) -> c19(IF_RM(true, s(0), add(s(0), x2)), EQ(s(0), s(0)))
   RM(s(0), add(s(s(z0)), x2)) -> c19(IF_RM(false, s(0), add(s(s(z0)), x2)), EQ(s(0), s(s(z0))))
   RM(s(s(z0)), add(s(0), x2)) -> c19(IF_RM(false, s(s(z0)), add(s(0), x2)), EQ(s(s(z0)), s(0)))
   RM(s(s(z0)), add(s(s(z1)), x2)) -> c19(IF_RM(eq(z0, z1), s(s(z0)), add(s(s(z1)), x2)), EQ(s(s(z0)), s(s(z1))))
   RM(s(x0), add(s(x1), x2)) -> c19(EQ(s(x0), s(x1)))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c26(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))), MIN(add(0, add(z0, x2))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))), MIN(add(s(z0), add(0, x2))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c26(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))), MIN(add(s(z0), add(s(z1), x2))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c26(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))), MIN(add(z0, add(x1, x2))))
   IF(false, add(z0, nil), x2, x3) -> c26(IF2(eq(z0, z0), add(z0, nil), x2, x3), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(z0, nil), x1, x2) -> c25(IF2(eq(z0, z0), add(z0, nil), x1, x2), EQ(head(add(z0, nil)), min(add(z0, nil))))
   IF(false, add(0, add(z0, x2)), x3, x4) -> c25(IF2(eq(head(add(0, add(z0, x2))), if_min(true, add(0, add(z0, x2)))), add(0, add(z0, x2)), x3, x4), EQ(head(add(0, add(z0, x2))), min(add(0, add(z0, x2)))))
   IF(false, add(s(z0), add(0, x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(0, x2))), if_min(false, add(s(z0), add(0, x2)))), add(s(z0), add(0, x2)), x3, x4), EQ(head(add(s(z0), add(0, x2))), min(add(s(z0), add(0, x2)))))
   IF(false, add(s(z0), add(s(z1), x2)), x3, x4) -> c25(IF2(eq(head(add(s(z0), add(s(z1), x2))), if_min(le(z0, z1), add(s(z0), add(s(z1), x2)))), add(s(z0), add(s(z1), x2)), x3, x4), EQ(head(add(s(z0), add(s(z1), x2))), min(add(s(z0), add(s(z1), x2)))))
   IF(false, add(z0, add(x1, x2)), x3, x4) -> c25(IF2(eq(z0, if_min(le(z0, x1), add(z0, add(x1, x2)))), add(z0, add(x1, x2)), x3, x4), EQ(head(add(z0, add(x1, x2))), min(add(z0, add(x1, x2)))))
   IF2(true, x0, x1, add(x2, nil)) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, x0, x1, add(x2, nil)) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(head(x0), nil))), APP(add(x2, nil), add(head(x0), nil)))
   IF2(true, x0, x1, add(x2, add(z0, z1))) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(x2, add(z0, app(z1, add(head(x0), nil))))), APP(add(x2, add(z0, z1)), add(head(x0), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(z0, nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, tail(add(z0, z1))), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(false, add(z0, z1), x2, x3) -> c30(MINS(z1, add(z0, x2), x3))
   IF2(false, add(z0, z1), x2, x3) -> c31(MINS(z1, add(z0, x2), x3))
K tuples:
   IF2(true, nil, x1, x2) -> c(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c27(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c1(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c1(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, x0, x1, nil) -> c28(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)), APP(rm(head(x0), tail(x0)), x1), RM(head(x0), tail(x0)))
   IF2(true, nil, x1, x2) -> c2(MINS(app(rm(head(nil), nil), x1), nil, app(x2, add(head(nil), nil))))
   IF2(true, nil, x1, x2) -> c2(APP(x2, add(head(nil), nil)))
   IF2(true, x0, x1, nil) -> c29(MINS(app(rm(head(x0), tail(x0)), x1), nil, add(head(x0), nil)))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c26(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c26(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF(false, add(x0, nil), x1, x2) -> c26(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, nil), x1, x2) -> c25(EQ(head(add(x0, nil)), min(add(x0, nil))))
   IF(false, add(x0, add(x1, x2)), x3, x4) -> c25(EQ(head(add(x0, add(x1, x2))), min(add(x0, add(x1, x2)))))
   IF(false, add(x0, x1), x2, x3) -> c25(EQ(head(add(x0, x1)), min(add(x0, x1))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c5(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c27(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c9(APP(rm(head(nil), tail(nil)), x1))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), nil, add(z0, nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, nil) -> c28(MINS(app(rm(z0, tail(add(z0, z1))), x1), nil, add(head(add(z0, z1)), nil)), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(MINS(app(rm(head(nil), nil), x1), nil, add(x2, app(x3, add(head(nil), nil)))))
   IF2(true, nil, x1, add(x2, x3)) -> c13(APP(add(x2, x3), add(head(nil), nil)))
   IF2(true, x0, x1, add(x2, x3)) -> c29(APP(add(x2, x3), add(head(x0), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), tail(add(x0, x1))), x2), nil, add(x0, nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(head(add(x0, x1)), x1), x2), nil, add(head(add(x0, x1)), nil)))
   IF2(true, add(x0, x1), x2, nil) -> c29(MINS(app(rm(x0, tail(add(x0, x1))), x2), nil, add(head(add(x0, x1)), nil)))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c27(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c27(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c27(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x1), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(x0, nil), x2, x3) -> c28(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(rm(head(add(x0, nil)), tail(add(x0, nil))), x2), RM(head(add(x0, nil)), tail(add(x0, nil))))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c28(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(rm(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))), x2), RM(head(add(x0, add(z1, z2))), tail(add(x0, add(z1, z2)))))
   IF2(true, add(z0, z1), x2, x3) -> c28(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(rm(head(add(z0, z1)), tail(add(z0, z1))), x2), RM(head(add(z0, z1)), tail(add(z0, z1))))
   IF2(true, add(z0, z1), x1, add(x2, x3)) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x1), nil, add(x2, app(x3, add(head(add(z0, z1)), nil)))), APP(add(x2, x3), add(head(add(z0, z1)), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(head(add(z0, z1)), z1), x2), nil, app(x3, add(z0, nil))), APP(x3, add(head(add(z0, z1)), nil)))
   IF2(true, add(x0, nil), x2, x3) -> c29(MINS(app(nil, x2), nil, app(x3, add(head(add(x0, nil)), nil))), APP(x3, add(head(add(x0, nil)), nil)))
   IF2(true, add(x0, add(z1, z2)), x2, x3) -> c29(MINS(app(if_rm(eq(head(add(x0, add(z1, z2))), z1), head(add(x0, add(z1, z2))), add(z1, z2)), x2), nil, app(x3, add(head(add(x0, add(z1, z2))), nil))), APP(x3, add(head(add(x0, add(z1, z2))), nil)))
   IF2(true, add(z0, z1), x2, x3) -> c29(MINS(app(rm(z0, z1), x2), nil, app(x3, add(head(add(z0, z1)), nil))), APP(x3, add(head(add(z0, z1)), nil)))
Defined Rule Symbols:   eq_2, head_1, min_1, if_min_2, le_2, app_2, rm_2, tail_1, if_rm_3

Defined Pair Symbols:   EQ_2, LE_2, APP_2, IF_MIN_2, IF_RM_3, MIN_1, RM_2, MINS_3, IF2_4, IF_4

Compound Symbols:   c3_1, c6_1, c8_1, c11_1, c12_1, c20_1, c21_1, c10_1, c19_1, c23_1, c2_1, c10_2, c19_2, c26_3, c26_1, c26_2, c25_2, c25_1, c27_3, c4_1, c5_1, c_1, c28_3, c7_1, c9_1, c1_1, c29_2, c29_1, c13_1, c30_1, c31_1