KILLED
proof of input_PuLVn2bF79.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), 6 ms]
        (14) CpxRNTS
        (15) SimplificationProof [BOTH BOUNDS(ID, ID), 4 ms]
        (16) CpxRNTS
        (17) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 2 ms]
        (18) CpxRNTS
        (19) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (20) CpxRNTS
        (21) IntTrsBoundProof [UPPER BOUND(ID), 424 ms]
        (22) CpxRNTS
        (23) IntTrsBoundProof [UPPER BOUND(ID), 162 ms]
        (24) CpxRNTS
        (25) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (26) CpxRNTS
        (27) IntTrsBoundProof [UPPER BOUND(ID), 285 ms]
        (28) CpxRNTS
        (29) IntTrsBoundProof [UPPER BOUND(ID), 77 ms]
        (30) CpxRNTS
        (31) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (32) CpxRNTS
        (33) IntTrsBoundProof [UPPER BOUND(ID), 221 ms]
        (34) CpxRNTS
        (35) IntTrsBoundProof [UPPER BOUND(ID), 5 ms]
        (36) CpxRNTS
        (37) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (38) CpxRNTS
        (39) IntTrsBoundProof [UPPER BOUND(ID), 108 ms]
        (40) CpxRNTS
        (41) IntTrsBoundProof [UPPER BOUND(ID), 3 ms]
        (42) CpxRNTS
        (43) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (44) CpxRNTS
        (45) IntTrsBoundProof [UPPER BOUND(ID), 271 ms]
        (46) CpxRNTS
        (47) IntTrsBoundProof [UPPER BOUND(ID), 24 ms]
        (48) CpxRNTS
        (49) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (50) CpxRNTS
        (51) IntTrsBoundProof [UPPER BOUND(ID), 87 ms]
        (52) CpxRNTS
        (53) IntTrsBoundProof [UPPER BOUND(ID), 2 ms]
        (54) CpxRNTS
        (55) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (56) CpxRNTS
        (57) IntTrsBoundProof [UPPER BOUND(ID), 4726 ms]
        (58) CpxRNTS
        (59) IntTrsBoundProof [UPPER BOUND(ID), 1231 ms]
        (60) CpxRNTS
    (61) CompletionProof [UPPER BOUND(ID), 0 ms]
    (62) CpxTypedWeightedCompleteTrs
        (63) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 2 ms]
        (64) CpxRNTS
(65) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms]
(66) CdtProblem
    (67) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms]
    (68) CdtProblem
    (69) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (70) CdtProblem
    (71) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms]
    (72) CdtProblem
    (73) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (74) CdtProblem
    (75) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (76) CdtProblem
    (77) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (78) CdtProblem
    (79) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (80) CdtProblem
    (81) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (82) CdtProblem
    (83) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (84) CdtProblem
    (85) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (86) CdtProblem
    (87) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (88) CdtProblem
    (89) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
    (90) CdtProblem
    (91) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms]
    (92) CdtProblem
    (93) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (94) CdtProblem
    (95) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (96) CdtProblem
    (97) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (98) CdtProblem
    (99) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
    (100) CdtProblem
    (101) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (102) CdtProblem
    (103) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (104) CdtProblem
    (105) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (106) CdtProblem
    (107) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (108) CdtProblem
    (109) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (110) CdtProblem
    (111) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (112) CdtProblem
    (113) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
    (114) CdtProblem
    (115) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (116) CdtProblem
    (117) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (118) CdtProblem
    (119) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms]
    (120) CdtProblem
    (121) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (122) CdtProblem
    (123) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (124) CdtProblem
    (125) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 50 ms]
    (126) CdtProblem
    (127) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 1 ms]
    (128) CdtProblem
    (129) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (130) CdtProblem
    (131) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 87 ms]
    (132) CdtProblem
    (133) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (134) CdtProblem
    (135) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (136) CdtProblem
    (137) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (138) CdtProblem
    (139) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (140) CdtProblem
    (141) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (142) CdtProblem
    (143) CdtRhsSimplificationProcessorProof [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)), 77 ms]
    (150) CdtProblem
    (151) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (152) CdtProblem
    (153) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (154) CdtProblem
    (155) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms]
    (156) CdtProblem
    (157) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (158) CdtProblem
    (159) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (160) CdtProblem
    (161) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (162) CdtProblem
    (163) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (164) CdtProblem
    (165) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 123 ms]
    (166) CdtProblem
    (167) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (168) CdtProblem
    (169) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (170) CdtProblem
    (171) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
    (172) CdtProblem
    (173) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (174) CdtProblem
    (175) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (176) CdtProblem
    (177) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (178) CdtProblem
    (179) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (180) CdtProblem
    (181) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 108 ms]
    (182) CdtProblem
    (183) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (184) CdtProblem
    (185) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (186) CdtProblem
    (187) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (188) CdtProblem
    (189) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (190) CdtProblem
    (191) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (192) CdtProblem
    (193) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (194) CdtProblem
    (195) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (196) CdtProblem
    (197) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 131 ms]
    (198) CdtProblem
    (199) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (200) CdtProblem
    (201) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 197 ms]
    (202) CdtProblem
    (203) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (204) CdtProblem
    (205) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (206) CdtProblem
    (207) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (208) CdtProblem
    (209) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
    (210) CdtProblem
    (211) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 179 ms]
    (212) CdtProblem
    (213) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (214) CdtProblem
    (215) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (216) CdtProblem
    (217) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (218) CdtProblem
    (219) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (220) CdtProblem
    (221) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (222) CdtProblem
    (223) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (224) CdtProblem
    (225) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (226) CdtProblem
    (227) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (228) CdtProblem
    (229) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 176 ms]
    (230) CdtProblem
    (231) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (232) CdtProblem
    (233) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (234) CdtProblem
    (235) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 209 ms]
    (236) CdtProblem
    (237) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (238) CdtProblem
    (239) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (240) CdtProblem
    (241) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 1 ms]
    (242) CdtProblem
    (243) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (244) CdtProblem
    (245) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (246) CdtProblem
    (247) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 169 ms]
    (248) CdtProblem
    (249) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (250) CdtProblem
    (251) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (252) 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:

   le(s(x), 0) -> false
   le(0, y) -> true
   le(s(x), s(y)) -> le(x, y)
   double(0) -> 0
   double(s(x)) -> s(s(double(x)))
   log(0) -> logError
   log(s(x)) -> loop(s(x), s(0), 0)
   loop(x, s(y), z) -> if(le(x, s(y)), x, s(y), z)
   if(true, x, y, z) -> z
   if(false, x, y, z) -> loop(x, double(y), s(z))
   maplog(xs) -> mapIter(xs, nil)
   mapIter(xs, ys) -> ifmap(isempty(xs), xs, ys)
   ifmap(true, xs, ys) -> ys
   ifmap(false, xs, ys) -> mapIter(droplast(xs), cons(log(last(xs)), ys))
   isempty(nil) -> true
   isempty(cons(x, xs)) -> false
   last(nil) -> error
   last(cons(x, nil)) -> x
   last(cons(x, cons(y, xs))) -> last(cons(y, xs))
   droplast(nil) -> nil
   droplast(cons(x, nil)) -> nil
   droplast(cons(x, cons(y, xs))) -> cons(x, droplast(cons(y, xs)))
   a -> b
   a -> c

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:

   le(s(x), 0') -> false
   le(0', y) -> true
   le(s(x), s(y)) -> le(x, y)
   double(0') -> 0'
   double(s(x)) -> s(s(double(x)))
   log(0') -> logError
   log(s(x)) -> loop(s(x), s(0'), 0')
   loop(x, s(y), z) -> if(le(x, s(y)), x, s(y), z)
   if(true, x, y, z) -> z
   if(false, x, y, z) -> loop(x, double(y), s(z))
   maplog(xs) -> mapIter(xs, nil)
   mapIter(xs, ys) -> ifmap(isempty(xs), xs, ys)
   ifmap(true, xs, ys) -> ys
   ifmap(false, xs, ys) -> mapIter(droplast(xs), cons(log(last(xs)), ys))
   isempty(nil) -> true
   isempty(cons(x, xs)) -> false
   last(nil) -> error
   last(cons(x, nil)) -> x
   last(cons(x, cons(y, xs))) -> last(cons(y, xs))
   droplast(nil) -> nil
   droplast(cons(x, nil)) -> nil
   droplast(cons(x, cons(y, xs))) -> cons(x, droplast(cons(y, xs)))
   a -> b
   a -> c

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:

   le(s(x), 0) -> false
   le(0, y) -> true
   le(s(x), s(y)) -> le(x, y)
   double(0) -> 0
   double(s(x)) -> s(s(double(x)))
   log(0) -> logError
   log(s(x)) -> loop(s(x), s(0), 0)
   loop(x, s(y), z) -> if(le(x, s(y)), x, s(y), z)
   if(true, x, y, z) -> z
   if(false, x, y, z) -> loop(x, double(y), s(z))
   maplog(xs) -> mapIter(xs, nil)
   mapIter(xs, ys) -> ifmap(isempty(xs), xs, ys)
   ifmap(true, xs, ys) -> ys
   ifmap(false, xs, ys) -> mapIter(droplast(xs), cons(log(last(xs)), ys))
   isempty(nil) -> true
   isempty(cons(x, xs)) -> false
   last(nil) -> error
   last(cons(x, nil)) -> x
   last(cons(x, cons(y, xs))) -> last(cons(y, xs))
   droplast(nil) -> nil
   droplast(cons(x, nil)) -> nil
   droplast(cons(x, cons(y, xs))) -> cons(x, droplast(cons(y, xs)))
   a -> b
   a -> c

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:

   le(s(x), 0) -> false [1]
   le(0, y) -> true [1]
   le(s(x), s(y)) -> le(x, y) [1]
   double(0) -> 0 [1]
   double(s(x)) -> s(s(double(x))) [1]
   log(0) -> logError [1]
   log(s(x)) -> loop(s(x), s(0), 0) [1]
   loop(x, s(y), z) -> if(le(x, s(y)), x, s(y), z) [1]
   if(true, x, y, z) -> z [1]
   if(false, x, y, z) -> loop(x, double(y), s(z)) [1]
   maplog(xs) -> mapIter(xs, nil) [1]
   mapIter(xs, ys) -> ifmap(isempty(xs), xs, ys) [1]
   ifmap(true, xs, ys) -> ys [1]
   ifmap(false, xs, ys) -> mapIter(droplast(xs), cons(log(last(xs)), ys)) [1]
   isempty(nil) -> true [1]
   isempty(cons(x, xs)) -> false [1]
   last(nil) -> error [1]
   last(cons(x, nil)) -> x [1]
   last(cons(x, cons(y, xs))) -> last(cons(y, xs)) [1]
   droplast(nil) -> nil [1]
   droplast(cons(x, nil)) -> nil [1]
   droplast(cons(x, cons(y, xs))) -> cons(x, droplast(cons(y, xs))) [1]
   a -> b [1]
   a -> c [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:

   le(s(x), 0) -> false [1]
   le(0, y) -> true [1]
   le(s(x), s(y)) -> le(x, y) [1]
   double(0) -> 0 [1]
   double(s(x)) -> s(s(double(x))) [1]
   log(0) -> logError [1]
   log(s(x)) -> loop(s(x), s(0), 0) [1]
   loop(x, s(y), z) -> if(le(x, s(y)), x, s(y), z) [1]
   if(true, x, y, z) -> z [1]
   if(false, x, y, z) -> loop(x, double(y), s(z)) [1]
   maplog(xs) -> mapIter(xs, nil) [1]
   mapIter(xs, ys) -> ifmap(isempty(xs), xs, ys) [1]
   ifmap(true, xs, ys) -> ys [1]
   ifmap(false, xs, ys) -> mapIter(droplast(xs), cons(log(last(xs)), ys)) [1]
   isempty(nil) -> true [1]
   isempty(cons(x, xs)) -> false [1]
   last(nil) -> error [1]
   last(cons(x, nil)) -> x [1]
   last(cons(x, cons(y, xs))) -> last(cons(y, xs)) [1]
   droplast(nil) -> nil [1]
   droplast(cons(x, nil)) -> nil [1]
   droplast(cons(x, cons(y, xs))) -> cons(x, droplast(cons(y, xs))) [1]
   a -> b [1]
   a -> c [1]

The TRS has the following type information:
le :: s:0:logError:error -> s:0:logError:error -> false:true
s :: s:0:logError:error -> s:0:logError:error
0 :: s:0:logError:error
false :: false:true
true :: false:true
double :: s:0:logError:error -> s:0:logError:error
log :: s:0:logError:error -> s:0:logError:error
logError :: s:0:logError:error
loop :: s:0:logError:error -> s:0:logError:error -> s:0:logError:error -> s:0:logError:error
if :: false:true -> s:0:logError:error -> s:0:logError:error -> s:0:logError:error -> s:0:logError:error
maplog :: nil:cons -> nil:cons
mapIter :: nil:cons -> nil:cons -> nil:cons
nil :: nil:cons
ifmap :: false:true -> nil:cons -> nil:cons -> nil:cons
isempty :: nil:cons -> false:true
droplast :: nil:cons -> nil:cons
cons :: s:0:logError:error -> nil:cons -> nil:cons
last :: nil:cons -> s:0:logError:error
error :: s:0:logError:error
a :: b:c
b :: b:c
c :: b:c

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:

   maplog_1
   mapIter_2
   ifmap_3
   a

(c) The following functions are completely defined:

   droplast_1
   log_1
   last_1
   le_2
   double_1
   isempty_1
   loop_3
   if_4

Due to the following rules being added:

   log(v0) -> null_log [0]
   le(v0, v1) -> null_le [0]
   double(v0) -> null_double [0]
   loop(v0, v1, v2) -> null_loop [0]
   if(v0, v1, v2, v3) -> null_if [0]

And the following fresh constants:    null_log, null_le, null_double, null_loop, null_if

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

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

   le(s(x), 0) -> false [1]
   le(0, y) -> true [1]
   le(s(x), s(y)) -> le(x, y) [1]
   double(0) -> 0 [1]
   double(s(x)) -> s(s(double(x))) [1]
   log(0) -> logError [1]
   log(s(x)) -> loop(s(x), s(0), 0) [1]
   loop(x, s(y), z) -> if(le(x, s(y)), x, s(y), z) [1]
   if(true, x, y, z) -> z [1]
   if(false, x, y, z) -> loop(x, double(y), s(z)) [1]
   maplog(xs) -> mapIter(xs, nil) [1]
   mapIter(xs, ys) -> ifmap(isempty(xs), xs, ys) [1]
   ifmap(true, xs, ys) -> ys [1]
   ifmap(false, xs, ys) -> mapIter(droplast(xs), cons(log(last(xs)), ys)) [1]
   isempty(nil) -> true [1]
   isempty(cons(x, xs)) -> false [1]
   last(nil) -> error [1]
   last(cons(x, nil)) -> x [1]
   last(cons(x, cons(y, xs))) -> last(cons(y, xs)) [1]
   droplast(nil) -> nil [1]
   droplast(cons(x, nil)) -> nil [1]
   droplast(cons(x, cons(y, xs))) -> cons(x, droplast(cons(y, xs))) [1]
   a -> b [1]
   a -> c [1]
   log(v0) -> null_log [0]
   le(v0, v1) -> null_le [0]
   double(v0) -> null_double [0]
   loop(v0, v1, v2) -> null_loop [0]
   if(v0, v1, v2, v3) -> null_if [0]

The TRS has the following type information:
le :: s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if -> false:true:null_le
s :: s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if
0 :: s:0:logError:error:null_log:null_double:null_loop:null_if
false :: false:true:null_le
true :: false:true:null_le
double :: s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if
log :: s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if
logError :: s:0:logError:error:null_log:null_double:null_loop:null_if
loop :: s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if
if :: false:true:null_le -> s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if
maplog :: nil:cons -> nil:cons
mapIter :: nil:cons -> nil:cons -> nil:cons
nil :: nil:cons
ifmap :: false:true:null_le -> nil:cons -> nil:cons -> nil:cons
isempty :: nil:cons -> false:true:null_le
droplast :: nil:cons -> nil:cons
cons :: s:0:logError:error:null_log:null_double:null_loop:null_if -> nil:cons -> nil:cons
last :: nil:cons -> s:0:logError:error:null_log:null_double:null_loop:null_if
error :: s:0:logError:error:null_log:null_double:null_loop:null_if
a :: b:c
b :: b:c
c :: b:c
null_log :: s:0:logError:error:null_log:null_double:null_loop:null_if
null_le :: false:true:null_le
null_double :: s:0:logError:error:null_log:null_double:null_loop:null_if
null_loop :: s:0:logError:error:null_log:null_double:null_loop:null_if
null_if :: s:0:logError:error:null_log:null_double:null_loop:null_if

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:

   le(s(x), 0) -> false [1]
   le(0, y) -> true [1]
   le(s(x), s(y)) -> le(x, y) [1]
   double(0) -> 0 [1]
   double(s(x)) -> s(s(double(x))) [1]
   log(0) -> logError [1]
   log(s(x)) -> loop(s(x), s(0), 0) [1]
   loop(0, s(y), z) -> if(true, 0, s(y), z) [2]
   loop(s(x'), s(y), z) -> if(le(x', y), s(x'), s(y), z) [2]
   loop(x, s(y), z) -> if(null_le, x, s(y), z) [1]
   if(true, x, y, z) -> z [1]
   if(false, x, 0, z) -> loop(x, 0, s(z)) [2]
   if(false, x, s(x''), z) -> loop(x, s(s(double(x''))), s(z)) [2]
   if(false, x, y, z) -> loop(x, null_double, s(z)) [1]
   maplog(xs) -> mapIter(xs, nil) [1]
   mapIter(nil, ys) -> ifmap(true, nil, ys) [2]
   mapIter(cons(x1, xs'), ys) -> ifmap(false, cons(x1, xs'), ys) [2]
   ifmap(true, xs, ys) -> ys [1]
   ifmap(false, nil, ys) -> mapIter(nil, cons(log(error), ys)) [3]
   ifmap(false, cons(x2, nil), ys) -> mapIter(nil, cons(log(x2), ys)) [3]
   ifmap(false, cons(x3, cons(y', xs'')), ys) -> mapIter(cons(x3, droplast(cons(y', xs''))), cons(log(last(cons(y', xs''))), ys)) [3]
   isempty(nil) -> true [1]
   isempty(cons(x, xs)) -> false [1]
   last(nil) -> error [1]
   last(cons(x, nil)) -> x [1]
   last(cons(x, cons(y, xs))) -> last(cons(y, xs)) [1]
   droplast(nil) -> nil [1]
   droplast(cons(x, nil)) -> nil [1]
   droplast(cons(x, cons(y, xs))) -> cons(x, droplast(cons(y, xs))) [1]
   a -> b [1]
   a -> c [1]
   log(v0) -> null_log [0]
   le(v0, v1) -> null_le [0]
   double(v0) -> null_double [0]
   loop(v0, v1, v2) -> null_loop [0]
   if(v0, v1, v2, v3) -> null_if [0]

The TRS has the following type information:
le :: s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if -> false:true:null_le
s :: s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if
0 :: s:0:logError:error:null_log:null_double:null_loop:null_if
false :: false:true:null_le
true :: false:true:null_le
double :: s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if
log :: s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if
logError :: s:0:logError:error:null_log:null_double:null_loop:null_if
loop :: s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if
if :: false:true:null_le -> s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if -> s:0:logError:error:null_log:null_double:null_loop:null_if
maplog :: nil:cons -> nil:cons
mapIter :: nil:cons -> nil:cons -> nil:cons
nil :: nil:cons
ifmap :: false:true:null_le -> nil:cons -> nil:cons -> nil:cons
isempty :: nil:cons -> false:true:null_le
droplast :: nil:cons -> nil:cons
cons :: s:0:logError:error:null_log:null_double:null_loop:null_if -> nil:cons -> nil:cons
last :: nil:cons -> s:0:logError:error:null_log:null_double:null_loop:null_if
error :: s:0:logError:error:null_log:null_double:null_loop:null_if
a :: b:c
b :: b:c
c :: b:c
null_log :: s:0:logError:error:null_log:null_double:null_loop:null_if
null_le :: false:true:null_le
null_double :: s:0:logError:error:null_log:null_double:null_loop:null_if
null_loop :: s:0:logError:error:null_log:null_double:null_loop:null_if
null_if :: s:0:logError:error:null_log:null_double:null_loop:null_if

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
   false => 1
   true => 2
   logError => 2
   nil => 0
   error => 1
   b => 0
   c => 1
   null_log => 0
   null_le => 0
   null_double => 0
   null_loop => 0
   null_if => 0

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

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

   a -{ 1 }-> 1 :|: 
   a -{ 1 }-> 0 :|: 
   double(z') -{ 1 }-> 0 :|: z' = 0
   double(z') -{ 0 }-> 0 :|: v0 >= 0, z' = v0
   double(z') -{ 1 }-> 1 + (1 + double(x)) :|: z' = 1 + x, x >= 0
   droplast(z') -{ 1 }-> 0 :|: z' = 0
   droplast(z') -{ 1 }-> 0 :|: x >= 0, z' = 1 + x + 0
   droplast(z') -{ 1 }-> 1 + x + droplast(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   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) -{ 2 }-> loop(x, 0, 1 + z) :|: z1 = 0, z >= 0, z2 = z, x >= 0, z'' = x, z' = 1
   if(z', z'', z1, z2) -{ 1 }-> loop(x, 0, 1 + z) :|: z1 = y, z >= 0, z2 = z, x >= 0, y >= 0, z'' = x, z' = 1
   if(z', z'', z1, z2) -{ 2 }-> loop(x, 1 + (1 + double(x'')), 1 + z) :|: z >= 0, z1 = 1 + x'', z2 = z, x >= 0, z'' = x, z' = 1, x'' >= 0
   if(z', z'', z1, z2) -{ 0 }-> 0 :|: z2 = v3, v0 >= 0, z1 = v2, v1 >= 0, z'' = v1, v2 >= 0, v3 >= 0, z' = v0
   ifmap(z', z'', z1) -{ 1 }-> ys :|: xs >= 0, z' = 2, ys >= 0, z'' = xs, z1 = ys
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(x2) + ys) :|: z'' = 1 + x2 + 0, ys >= 0, z' = 1, x2 >= 0, z1 = ys
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + ys) :|: z'' = 0, ys >= 0, z' = 1, z1 = ys
   ifmap(z', z'', z1) -{ 3 }-> mapIter(1 + x3 + droplast(1 + y' + xs''), 1 + log(last(1 + y' + xs'')) + ys) :|: ys >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0, z1 = ys
   isempty(z') -{ 1 }-> 2 :|: z' = 0
   isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0
   last(z') -{ 1 }-> x :|: x >= 0, z' = 1 + x + 0
   last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   last(z') -{ 1 }-> 1 :|: z' = 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
   log(z') -{ 1 }-> loop(1 + x, 1 + 0, 0) :|: z' = 1 + x, x >= 0
   log(z') -{ 1 }-> 2 :|: z' = 0
   log(z') -{ 0 }-> 0 :|: v0 >= 0, z' = v0
   loop(z', z'', z1) -{ 2 }-> if(le(x', y), 1 + x', 1 + y, z) :|: z1 = z, z >= 0, z' = 1 + x', x' >= 0, y >= 0, z'' = 1 + y
   loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + y, z) :|: z1 = z, z >= 0, y >= 0, z'' = 1 + y, z' = 0
   loop(z', z'', z1) -{ 1 }-> if(0, x, 1 + y, z) :|: z1 = z, z >= 0, z' = x, x >= 0, y >= 0, z'' = 1 + y
   loop(z', z'', z1) -{ 0 }-> 0 :|: v0 >= 0, z1 = v2, v1 >= 0, z'' = v1, v2 >= 0, z' = v0
   mapIter(z', z'') -{ 2 }-> ifmap(2, 0, ys) :|: ys >= 0, z'' = ys, z' = 0
   mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', ys) :|: x1 >= 0, z' = 1 + x1 + xs', ys >= 0, xs' >= 0, z'' = ys
   maplog(z') -{ 1 }-> mapIter(xs, 0) :|: xs >= 0, z' = xs


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

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

   a -{ 1 }-> 1 :|: 
   a -{ 1 }-> 0 :|: 
   double(z') -{ 1 }-> 0 :|: z' = 0
   double(z') -{ 0 }-> 0 :|: z' >= 0
   double(z') -{ 1 }-> 1 + (1 + double(z' - 1)) :|: z' - 1 >= 0
   droplast(z') -{ 1 }-> 0 :|: z' = 0
   droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0
   droplast(z') -{ 1 }-> 1 + x + droplast(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1
   if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 1 + (1 + double(z1 - 1)), 1 + z2) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0
   if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0
   ifmap(z', z'', z1) -{ 3 }-> mapIter(1 + x3 + droplast(1 + y' + xs''), 1 + log(last(1 + y' + xs'')) + z1) :|: z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0
   isempty(z') -{ 1 }-> 2 :|: z' = 0
   isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0
   last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   last(z') -{ 1 }-> 1 :|: z' = 0
   last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   le(z', z'') -{ 1 }-> le(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0
   le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0
   log(z') -{ 1 }-> 2 :|: z' = 0
   log(z') -{ 0 }-> 0 :|: z' >= 0
   loop(z', z'', z1) -{ 2 }-> if(le(z' - 1, z'' - 1), 1 + (z' - 1), 1 + (z'' - 1), z1) :|: z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0
   loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0
   mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0
   maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0


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

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

   { le }
   { droplast }
   { double }
   { isempty }
   { last }
   { a }
   { if, loop }
   { log }
   { ifmap, mapIter }
   { maplog }

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

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

   a -{ 1 }-> 1 :|: 
   a -{ 1 }-> 0 :|: 
   double(z') -{ 1 }-> 0 :|: z' = 0
   double(z') -{ 0 }-> 0 :|: z' >= 0
   double(z') -{ 1 }-> 1 + (1 + double(z' - 1)) :|: z' - 1 >= 0
   droplast(z') -{ 1 }-> 0 :|: z' = 0
   droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0
   droplast(z') -{ 1 }-> 1 + x + droplast(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1
   if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 1 + (1 + double(z1 - 1)), 1 + z2) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0
   if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0
   ifmap(z', z'', z1) -{ 3 }-> mapIter(1 + x3 + droplast(1 + y' + xs''), 1 + log(last(1 + y' + xs'')) + z1) :|: z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0
   isempty(z') -{ 1 }-> 2 :|: z' = 0
   isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0
   last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   last(z') -{ 1 }-> 1 :|: z' = 0
   last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   le(z', z'') -{ 1 }-> le(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0
   le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0
   log(z') -{ 1 }-> 2 :|: z' = 0
   log(z') -{ 0 }-> 0 :|: z' >= 0
   loop(z', z'', z1) -{ 2 }-> if(le(z' - 1, z'' - 1), 1 + (z' - 1), 1 + (z'' - 1), z1) :|: z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0
   loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0
   mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0
   maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0

Function symbols to be analyzed: {le}, {droplast}, {double}, {isempty}, {last}, {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog}

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

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

   a -{ 1 }-> 1 :|: 
   a -{ 1 }-> 0 :|: 
   double(z') -{ 1 }-> 0 :|: z' = 0
   double(z') -{ 0 }-> 0 :|: z' >= 0
   double(z') -{ 1 }-> 1 + (1 + double(z' - 1)) :|: z' - 1 >= 0
   droplast(z') -{ 1 }-> 0 :|: z' = 0
   droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0
   droplast(z') -{ 1 }-> 1 + x + droplast(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1
   if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 1 + (1 + double(z1 - 1)), 1 + z2) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0
   if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0
   ifmap(z', z'', z1) -{ 3 }-> mapIter(1 + x3 + droplast(1 + y' + xs''), 1 + log(last(1 + y' + xs'')) + z1) :|: z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0
   isempty(z') -{ 1 }-> 2 :|: z' = 0
   isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0
   last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   last(z') -{ 1 }-> 1 :|: z' = 0
   last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   le(z', z'') -{ 1 }-> le(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0
   le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0
   log(z') -{ 1 }-> 2 :|: z' = 0
   log(z') -{ 0 }-> 0 :|: z' >= 0
   loop(z', z'', z1) -{ 2 }-> if(le(z' - 1, z'' - 1), 1 + (z' - 1), 1 + (z'' - 1), z1) :|: z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0
   loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0
   mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0
   maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0

Function symbols to be analyzed: {le}, {droplast}, {double}, {isempty}, {last}, {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog}

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

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

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

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

   a -{ 1 }-> 1 :|: 
   a -{ 1 }-> 0 :|: 
   double(z') -{ 1 }-> 0 :|: z' = 0
   double(z') -{ 0 }-> 0 :|: z' >= 0
   double(z') -{ 1 }-> 1 + (1 + double(z' - 1)) :|: z' - 1 >= 0
   droplast(z') -{ 1 }-> 0 :|: z' = 0
   droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0
   droplast(z') -{ 1 }-> 1 + x + droplast(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1
   if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 1 + (1 + double(z1 - 1)), 1 + z2) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0
   if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0
   ifmap(z', z'', z1) -{ 3 }-> mapIter(1 + x3 + droplast(1 + y' + xs''), 1 + log(last(1 + y' + xs'')) + z1) :|: z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0
   isempty(z') -{ 1 }-> 2 :|: z' = 0
   isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0
   last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   last(z') -{ 1 }-> 1 :|: z' = 0
   last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   le(z', z'') -{ 1 }-> le(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0
   le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0
   log(z') -{ 1 }-> 2 :|: z' = 0
   log(z') -{ 0 }-> 0 :|: z' >= 0
   loop(z', z'', z1) -{ 2 }-> if(le(z' - 1, z'' - 1), 1 + (z' - 1), 1 + (z'' - 1), z1) :|: z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0
   loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0
   mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0
   maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0

Function symbols to be analyzed: {le}, {droplast}, {double}, {isempty}, {last}, {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog}
Previous analysis results are:
  le: runtime: ?, size: O(1) [2]

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

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

   a -{ 1 }-> 1 :|: 
   a -{ 1 }-> 0 :|: 
   double(z') -{ 1 }-> 0 :|: z' = 0
   double(z') -{ 0 }-> 0 :|: z' >= 0
   double(z') -{ 1 }-> 1 + (1 + double(z' - 1)) :|: z' - 1 >= 0
   droplast(z') -{ 1 }-> 0 :|: z' = 0
   droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0
   droplast(z') -{ 1 }-> 1 + x + droplast(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1
   if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 1 + (1 + double(z1 - 1)), 1 + z2) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0
   if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0
   ifmap(z', z'', z1) -{ 3 }-> mapIter(1 + x3 + droplast(1 + y' + xs''), 1 + log(last(1 + y' + xs'')) + z1) :|: z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0
   isempty(z') -{ 1 }-> 2 :|: z' = 0
   isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0
   last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   last(z') -{ 1 }-> 1 :|: z' = 0
   last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   le(z', z'') -{ 1 }-> le(z' - 1, z'' - 1) :|: z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0
   le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0
   log(z') -{ 1 }-> 2 :|: z' = 0
   log(z') -{ 0 }-> 0 :|: z' >= 0
   loop(z', z'', z1) -{ 2 }-> if(le(z' - 1, z'' - 1), 1 + (z' - 1), 1 + (z'' - 1), z1) :|: z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0
   loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0
   mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0
   maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0

Function symbols to be analyzed: {droplast}, {double}, {isempty}, {last}, {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [2]

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

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

   a -{ 1 }-> 1 :|: 
   a -{ 1 }-> 0 :|: 
   double(z') -{ 1 }-> 0 :|: z' = 0
   double(z') -{ 0 }-> 0 :|: z' >= 0
   double(z') -{ 1 }-> 1 + (1 + double(z' - 1)) :|: z' - 1 >= 0
   droplast(z') -{ 1 }-> 0 :|: z' = 0
   droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0
   droplast(z') -{ 1 }-> 1 + x + droplast(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1
   if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 1 + (1 + double(z1 - 1)), 1 + z2) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0
   if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0
   ifmap(z', z'', z1) -{ 3 }-> mapIter(1 + x3 + droplast(1 + y' + xs''), 1 + log(last(1 + y' + xs'')) + z1) :|: z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0
   isempty(z') -{ 1 }-> 2 :|: z' = 0
   isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0
   last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   last(z') -{ 1 }-> 1 :|: z' = 0
   last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0
   le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0
   log(z') -{ 1 }-> 2 :|: z' = 0
   log(z') -{ 0 }-> 0 :|: z' >= 0
   loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0
   loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0
   mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0
   maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0

Function symbols to be analyzed: {droplast}, {double}, {isempty}, {last}, {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [2]

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

(27) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   a -{ 1 }-> 1 :|: 
   a -{ 1 }-> 0 :|: 
   double(z') -{ 1 }-> 0 :|: z' = 0
   double(z') -{ 0 }-> 0 :|: z' >= 0
   double(z') -{ 1 }-> 1 + (1 + double(z' - 1)) :|: z' - 1 >= 0
   droplast(z') -{ 1 }-> 0 :|: z' = 0
   droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0
   droplast(z') -{ 1 }-> 1 + x + droplast(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1
   if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 1 + (1 + double(z1 - 1)), 1 + z2) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0
   if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0
   ifmap(z', z'', z1) -{ 3 }-> mapIter(1 + x3 + droplast(1 + y' + xs''), 1 + log(last(1 + y' + xs'')) + z1) :|: z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0
   isempty(z') -{ 1 }-> 2 :|: z' = 0
   isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0
   last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   last(z') -{ 1 }-> 1 :|: z' = 0
   last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0
   le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0
   log(z') -{ 1 }-> 2 :|: z' = 0
   log(z') -{ 0 }-> 0 :|: z' >= 0
   loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0
   loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0
   mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0
   maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0

Function symbols to be analyzed: {droplast}, {double}, {isempty}, {last}, {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [2]
  droplast: runtime: ?, size: O(n^1) [z']

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

(29) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   a -{ 1 }-> 1 :|: 
   a -{ 1 }-> 0 :|: 
   double(z') -{ 1 }-> 0 :|: z' = 0
   double(z') -{ 0 }-> 0 :|: z' >= 0
   double(z') -{ 1 }-> 1 + (1 + double(z' - 1)) :|: z' - 1 >= 0
   droplast(z') -{ 1 }-> 0 :|: z' = 0
   droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0
   droplast(z') -{ 1 }-> 1 + x + droplast(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1
   if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 1 + (1 + double(z1 - 1)), 1 + z2) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0
   if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0
   ifmap(z', z'', z1) -{ 3 }-> mapIter(1 + x3 + droplast(1 + y' + xs''), 1 + log(last(1 + y' + xs'')) + z1) :|: z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0
   isempty(z') -{ 1 }-> 2 :|: z' = 0
   isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0
   last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   last(z') -{ 1 }-> 1 :|: z' = 0
   last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0
   le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0
   log(z') -{ 1 }-> 2 :|: z' = 0
   log(z') -{ 0 }-> 0 :|: z' >= 0
   loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0
   loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0
   mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0
   maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0

Function symbols to be analyzed: {double}, {isempty}, {last}, {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [2]
  droplast: runtime: O(n^1) [2 + z'], size: O(n^1) [z']

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

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

   a -{ 1 }-> 1 :|: 
   a -{ 1 }-> 0 :|: 
   double(z') -{ 1 }-> 0 :|: z' = 0
   double(z') -{ 0 }-> 0 :|: z' >= 0
   double(z') -{ 1 }-> 1 + (1 + double(z' - 1)) :|: z' - 1 >= 0
   droplast(z') -{ 1 }-> 0 :|: z' = 0
   droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0
   droplast(z') -{ 4 + xs + y }-> 1 + x + s1 :|: s1 >= 0, s1 <= 1 + y + xs, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1
   if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 1 + (1 + double(z1 - 1)), 1 + z2) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0
   if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0
   ifmap(z', z'', z1) -{ 6 + xs'' + y' }-> mapIter(1 + x3 + s'', 1 + log(last(1 + y' + xs'')) + z1) :|: s'' >= 0, s'' <= 1 + y' + xs'', z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0
   isempty(z') -{ 1 }-> 2 :|: z' = 0
   isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0
   last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   last(z') -{ 1 }-> 1 :|: z' = 0
   last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0
   le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0
   log(z') -{ 1 }-> 2 :|: z' = 0
   log(z') -{ 0 }-> 0 :|: z' >= 0
   loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0
   loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0
   mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0
   maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0

Function symbols to be analyzed: {double}, {isempty}, {last}, {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [2]
  droplast: runtime: O(n^1) [2 + z'], size: O(n^1) [z']

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

(33) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   a -{ 1 }-> 1 :|: 
   a -{ 1 }-> 0 :|: 
   double(z') -{ 1 }-> 0 :|: z' = 0
   double(z') -{ 0 }-> 0 :|: z' >= 0
   double(z') -{ 1 }-> 1 + (1 + double(z' - 1)) :|: z' - 1 >= 0
   droplast(z') -{ 1 }-> 0 :|: z' = 0
   droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0
   droplast(z') -{ 4 + xs + y }-> 1 + x + s1 :|: s1 >= 0, s1 <= 1 + y + xs, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1
   if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 1 + (1 + double(z1 - 1)), 1 + z2) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0
   if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0
   ifmap(z', z'', z1) -{ 6 + xs'' + y' }-> mapIter(1 + x3 + s'', 1 + log(last(1 + y' + xs'')) + z1) :|: s'' >= 0, s'' <= 1 + y' + xs'', z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0
   isempty(z') -{ 1 }-> 2 :|: z' = 0
   isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0
   last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   last(z') -{ 1 }-> 1 :|: z' = 0
   last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0
   le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0
   log(z') -{ 1 }-> 2 :|: z' = 0
   log(z') -{ 0 }-> 0 :|: z' >= 0
   loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0
   loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0
   mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0
   maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0

Function symbols to be analyzed: {double}, {isempty}, {last}, {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [2]
  droplast: runtime: O(n^1) [2 + z'], size: O(n^1) [z']
  double: runtime: ?, size: O(n^1) [2*z']

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

(35) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   a -{ 1 }-> 1 :|: 
   a -{ 1 }-> 0 :|: 
   double(z') -{ 1 }-> 0 :|: z' = 0
   double(z') -{ 0 }-> 0 :|: z' >= 0
   double(z') -{ 1 }-> 1 + (1 + double(z' - 1)) :|: z' - 1 >= 0
   droplast(z') -{ 1 }-> 0 :|: z' = 0
   droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0
   droplast(z') -{ 4 + xs + y }-> 1 + x + s1 :|: s1 >= 0, s1 <= 1 + y + xs, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1
   if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 1 + (1 + double(z1 - 1)), 1 + z2) :|: z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0
   if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0
   ifmap(z', z'', z1) -{ 6 + xs'' + y' }-> mapIter(1 + x3 + s'', 1 + log(last(1 + y' + xs'')) + z1) :|: s'' >= 0, s'' <= 1 + y' + xs'', z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0
   isempty(z') -{ 1 }-> 2 :|: z' = 0
   isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0
   last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   last(z') -{ 1 }-> 1 :|: z' = 0
   last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0
   le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0
   log(z') -{ 1 }-> 2 :|: z' = 0
   log(z') -{ 0 }-> 0 :|: z' >= 0
   loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0
   loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0
   mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0
   maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0

Function symbols to be analyzed: {isempty}, {last}, {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [2]
  droplast: runtime: O(n^1) [2 + z'], size: O(n^1) [z']
  double: runtime: O(n^1) [1 + z'], size: O(n^1) [2*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:

   a -{ 1 }-> 1 :|: 
   a -{ 1 }-> 0 :|: 
   double(z') -{ 1 }-> 0 :|: z' = 0
   double(z') -{ 0 }-> 0 :|: z' >= 0
   double(z') -{ 1 + z' }-> 1 + (1 + s2) :|: s2 >= 0, s2 <= 2 * (z' - 1), z' - 1 >= 0
   droplast(z') -{ 1 }-> 0 :|: z' = 0
   droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0
   droplast(z') -{ 4 + xs + y }-> 1 + x + s1 :|: s1 >= 0, s1 <= 1 + y + xs, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1
   if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 2 + z1 }-> loop(z'', 1 + (1 + s3), 1 + z2) :|: s3 >= 0, s3 <= 2 * (z1 - 1), z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0
   if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0
   ifmap(z', z'', z1) -{ 6 + xs'' + y' }-> mapIter(1 + x3 + s'', 1 + log(last(1 + y' + xs'')) + z1) :|: s'' >= 0, s'' <= 1 + y' + xs'', z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0
   isempty(z') -{ 1 }-> 2 :|: z' = 0
   isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0
   last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   last(z') -{ 1 }-> 1 :|: z' = 0
   last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0
   le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0
   log(z') -{ 1 }-> 2 :|: z' = 0
   log(z') -{ 0 }-> 0 :|: z' >= 0
   loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0
   loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0
   mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0
   maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0

Function symbols to be analyzed: {isempty}, {last}, {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [2]
  droplast: runtime: O(n^1) [2 + z'], size: O(n^1) [z']
  double: runtime: O(n^1) [1 + z'], size: O(n^1) [2*z']

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

(39) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   a -{ 1 }-> 1 :|: 
   a -{ 1 }-> 0 :|: 
   double(z') -{ 1 }-> 0 :|: z' = 0
   double(z') -{ 0 }-> 0 :|: z' >= 0
   double(z') -{ 1 + z' }-> 1 + (1 + s2) :|: s2 >= 0, s2 <= 2 * (z' - 1), z' - 1 >= 0
   droplast(z') -{ 1 }-> 0 :|: z' = 0
   droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0
   droplast(z') -{ 4 + xs + y }-> 1 + x + s1 :|: s1 >= 0, s1 <= 1 + y + xs, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1
   if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 2 + z1 }-> loop(z'', 1 + (1 + s3), 1 + z2) :|: s3 >= 0, s3 <= 2 * (z1 - 1), z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0
   if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0
   ifmap(z', z'', z1) -{ 6 + xs'' + y' }-> mapIter(1 + x3 + s'', 1 + log(last(1 + y' + xs'')) + z1) :|: s'' >= 0, s'' <= 1 + y' + xs'', z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0
   isempty(z') -{ 1 }-> 2 :|: z' = 0
   isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0
   last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   last(z') -{ 1 }-> 1 :|: z' = 0
   last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0
   le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0
   log(z') -{ 1 }-> 2 :|: z' = 0
   log(z') -{ 0 }-> 0 :|: z' >= 0
   loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0
   loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0
   mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0
   maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0

Function symbols to be analyzed: {isempty}, {last}, {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [2]
  droplast: runtime: O(n^1) [2 + z'], size: O(n^1) [z']
  double: runtime: O(n^1) [1 + z'], size: O(n^1) [2*z']
  isempty: runtime: ?, size: O(1) [2]

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

(41) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using CoFloCo for: isempty
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:

   a -{ 1 }-> 1 :|: 
   a -{ 1 }-> 0 :|: 
   double(z') -{ 1 }-> 0 :|: z' = 0
   double(z') -{ 0 }-> 0 :|: z' >= 0
   double(z') -{ 1 + z' }-> 1 + (1 + s2) :|: s2 >= 0, s2 <= 2 * (z' - 1), z' - 1 >= 0
   droplast(z') -{ 1 }-> 0 :|: z' = 0
   droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0
   droplast(z') -{ 4 + xs + y }-> 1 + x + s1 :|: s1 >= 0, s1 <= 1 + y + xs, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1
   if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 2 + z1 }-> loop(z'', 1 + (1 + s3), 1 + z2) :|: s3 >= 0, s3 <= 2 * (z1 - 1), z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0
   if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0
   ifmap(z', z'', z1) -{ 6 + xs'' + y' }-> mapIter(1 + x3 + s'', 1 + log(last(1 + y' + xs'')) + z1) :|: s'' >= 0, s'' <= 1 + y' + xs'', z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0
   isempty(z') -{ 1 }-> 2 :|: z' = 0
   isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0
   last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   last(z') -{ 1 }-> 1 :|: z' = 0
   last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0
   le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0
   log(z') -{ 1 }-> 2 :|: z' = 0
   log(z') -{ 0 }-> 0 :|: z' >= 0
   loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0
   loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0
   mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0
   maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0

Function symbols to be analyzed: {last}, {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [2]
  droplast: runtime: O(n^1) [2 + z'], size: O(n^1) [z']
  double: runtime: O(n^1) [1 + z'], size: O(n^1) [2*z']
  isempty: runtime: O(1) [1], size: O(1) [2]

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

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

   a -{ 1 }-> 1 :|: 
   a -{ 1 }-> 0 :|: 
   double(z') -{ 1 }-> 0 :|: z' = 0
   double(z') -{ 0 }-> 0 :|: z' >= 0
   double(z') -{ 1 + z' }-> 1 + (1 + s2) :|: s2 >= 0, s2 <= 2 * (z' - 1), z' - 1 >= 0
   droplast(z') -{ 1 }-> 0 :|: z' = 0
   droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0
   droplast(z') -{ 4 + xs + y }-> 1 + x + s1 :|: s1 >= 0, s1 <= 1 + y + xs, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1
   if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 2 + z1 }-> loop(z'', 1 + (1 + s3), 1 + z2) :|: s3 >= 0, s3 <= 2 * (z1 - 1), z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0
   if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0
   ifmap(z', z'', z1) -{ 6 + xs'' + y' }-> mapIter(1 + x3 + s'', 1 + log(last(1 + y' + xs'')) + z1) :|: s'' >= 0, s'' <= 1 + y' + xs'', z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0
   isempty(z') -{ 1 }-> 2 :|: z' = 0
   isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0
   last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   last(z') -{ 1 }-> 1 :|: z' = 0
   last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0
   le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0
   log(z') -{ 1 }-> 2 :|: z' = 0
   log(z') -{ 0 }-> 0 :|: z' >= 0
   loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0
   loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0
   mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0
   maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0

Function symbols to be analyzed: {last}, {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [2]
  droplast: runtime: O(n^1) [2 + z'], size: O(n^1) [z']
  double: runtime: O(n^1) [1 + z'], size: O(n^1) [2*z']
  isempty: runtime: O(1) [1], size: O(1) [2]

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

(45) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   a -{ 1 }-> 1 :|: 
   a -{ 1 }-> 0 :|: 
   double(z') -{ 1 }-> 0 :|: z' = 0
   double(z') -{ 0 }-> 0 :|: z' >= 0
   double(z') -{ 1 + z' }-> 1 + (1 + s2) :|: s2 >= 0, s2 <= 2 * (z' - 1), z' - 1 >= 0
   droplast(z') -{ 1 }-> 0 :|: z' = 0
   droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0
   droplast(z') -{ 4 + xs + y }-> 1 + x + s1 :|: s1 >= 0, s1 <= 1 + y + xs, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1
   if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 2 + z1 }-> loop(z'', 1 + (1 + s3), 1 + z2) :|: s3 >= 0, s3 <= 2 * (z1 - 1), z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0
   if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0
   ifmap(z', z'', z1) -{ 6 + xs'' + y' }-> mapIter(1 + x3 + s'', 1 + log(last(1 + y' + xs'')) + z1) :|: s'' >= 0, s'' <= 1 + y' + xs'', z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0
   isempty(z') -{ 1 }-> 2 :|: z' = 0
   isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0
   last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   last(z') -{ 1 }-> 1 :|: z' = 0
   last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0
   le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0
   log(z') -{ 1 }-> 2 :|: z' = 0
   log(z') -{ 0 }-> 0 :|: z' >= 0
   loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0
   loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0
   mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0
   maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0

Function symbols to be analyzed: {last}, {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [2]
  droplast: runtime: O(n^1) [2 + z'], size: O(n^1) [z']
  double: runtime: O(n^1) [1 + z'], size: O(n^1) [2*z']
  isempty: runtime: O(1) [1], size: O(1) [2]
  last: runtime: ?, size: O(n^1) [1 + z']

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

(47) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   a -{ 1 }-> 1 :|: 
   a -{ 1 }-> 0 :|: 
   double(z') -{ 1 }-> 0 :|: z' = 0
   double(z') -{ 0 }-> 0 :|: z' >= 0
   double(z') -{ 1 + z' }-> 1 + (1 + s2) :|: s2 >= 0, s2 <= 2 * (z' - 1), z' - 1 >= 0
   droplast(z') -{ 1 }-> 0 :|: z' = 0
   droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0
   droplast(z') -{ 4 + xs + y }-> 1 + x + s1 :|: s1 >= 0, s1 <= 1 + y + xs, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1
   if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 2 + z1 }-> loop(z'', 1 + (1 + s3), 1 + z2) :|: s3 >= 0, s3 <= 2 * (z1 - 1), z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0
   if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0
   ifmap(z', z'', z1) -{ 6 + xs'' + y' }-> mapIter(1 + x3 + s'', 1 + log(last(1 + y' + xs'')) + z1) :|: s'' >= 0, s'' <= 1 + y' + xs'', z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0
   isempty(z') -{ 1 }-> 2 :|: z' = 0
   isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0
   last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   last(z') -{ 1 }-> 1 :|: z' = 0
   last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0
   le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0
   log(z') -{ 1 }-> 2 :|: z' = 0
   log(z') -{ 0 }-> 0 :|: z' >= 0
   loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0
   loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0
   mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0
   maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0

Function symbols to be analyzed: {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [2]
  droplast: runtime: O(n^1) [2 + z'], size: O(n^1) [z']
  double: runtime: O(n^1) [1 + z'], size: O(n^1) [2*z']
  isempty: runtime: O(1) [1], size: O(1) [2]
  last: runtime: O(n^1) [2 + z'], size: O(n^1) [1 + z']

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

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

   a -{ 1 }-> 1 :|: 
   a -{ 1 }-> 0 :|: 
   double(z') -{ 1 }-> 0 :|: z' = 0
   double(z') -{ 0 }-> 0 :|: z' >= 0
   double(z') -{ 1 + z' }-> 1 + (1 + s2) :|: s2 >= 0, s2 <= 2 * (z' - 1), z' - 1 >= 0
   droplast(z') -{ 1 }-> 0 :|: z' = 0
   droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0
   droplast(z') -{ 4 + xs + y }-> 1 + x + s1 :|: s1 >= 0, s1 <= 1 + y + xs, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1
   if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 2 + z1 }-> loop(z'', 1 + (1 + s3), 1 + z2) :|: s3 >= 0, s3 <= 2 * (z1 - 1), z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0
   if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0
   ifmap(z', z'', z1) -{ 9 + 2*xs'' + 2*y' }-> mapIter(1 + x3 + s'', 1 + log(s4) + z1) :|: s4 >= 0, s4 <= 1 + y' + xs'' + 1, s'' >= 0, s'' <= 1 + y' + xs'', z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0
   isempty(z') -{ 1 }-> 2 :|: z' = 0
   isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0
   last(z') -{ 4 + xs + y }-> s5 :|: s5 >= 0, s5 <= 1 + y + xs + 1, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   last(z') -{ 1 }-> 1 :|: z' = 0
   last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0
   le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0
   log(z') -{ 1 }-> 2 :|: z' = 0
   log(z') -{ 0 }-> 0 :|: z' >= 0
   loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0
   loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0
   mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0
   maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0

Function symbols to be analyzed: {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [2]
  droplast: runtime: O(n^1) [2 + z'], size: O(n^1) [z']
  double: runtime: O(n^1) [1 + z'], size: O(n^1) [2*z']
  isempty: runtime: O(1) [1], size: O(1) [2]
  last: runtime: O(n^1) [2 + z'], size: O(n^1) [1 + z']

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

(51) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   a -{ 1 }-> 1 :|: 
   a -{ 1 }-> 0 :|: 
   double(z') -{ 1 }-> 0 :|: z' = 0
   double(z') -{ 0 }-> 0 :|: z' >= 0
   double(z') -{ 1 + z' }-> 1 + (1 + s2) :|: s2 >= 0, s2 <= 2 * (z' - 1), z' - 1 >= 0
   droplast(z') -{ 1 }-> 0 :|: z' = 0
   droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0
   droplast(z') -{ 4 + xs + y }-> 1 + x + s1 :|: s1 >= 0, s1 <= 1 + y + xs, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1
   if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 2 + z1 }-> loop(z'', 1 + (1 + s3), 1 + z2) :|: s3 >= 0, s3 <= 2 * (z1 - 1), z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0
   if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0
   ifmap(z', z'', z1) -{ 9 + 2*xs'' + 2*y' }-> mapIter(1 + x3 + s'', 1 + log(s4) + z1) :|: s4 >= 0, s4 <= 1 + y' + xs'' + 1, s'' >= 0, s'' <= 1 + y' + xs'', z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0
   isempty(z') -{ 1 }-> 2 :|: z' = 0
   isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0
   last(z') -{ 4 + xs + y }-> s5 :|: s5 >= 0, s5 <= 1 + y + xs + 1, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   last(z') -{ 1 }-> 1 :|: z' = 0
   last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0
   le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0
   log(z') -{ 1 }-> 2 :|: z' = 0
   log(z') -{ 0 }-> 0 :|: z' >= 0
   loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0
   loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0
   mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0
   maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0

Function symbols to be analyzed: {a}, {if,loop}, {log}, {ifmap,mapIter}, {maplog}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [2]
  droplast: runtime: O(n^1) [2 + z'], size: O(n^1) [z']
  double: runtime: O(n^1) [1 + z'], size: O(n^1) [2*z']
  isempty: runtime: O(1) [1], size: O(1) [2]
  last: runtime: O(n^1) [2 + z'], size: O(n^1) [1 + z']
  a: runtime: ?, size: O(1) [1]

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

(53) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   a -{ 1 }-> 1 :|: 
   a -{ 1 }-> 0 :|: 
   double(z') -{ 1 }-> 0 :|: z' = 0
   double(z') -{ 0 }-> 0 :|: z' >= 0
   double(z') -{ 1 + z' }-> 1 + (1 + s2) :|: s2 >= 0, s2 <= 2 * (z' - 1), z' - 1 >= 0
   droplast(z') -{ 1 }-> 0 :|: z' = 0
   droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0
   droplast(z') -{ 4 + xs + y }-> 1 + x + s1 :|: s1 >= 0, s1 <= 1 + y + xs, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1
   if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 2 + z1 }-> loop(z'', 1 + (1 + s3), 1 + z2) :|: s3 >= 0, s3 <= 2 * (z1 - 1), z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0
   if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0
   ifmap(z', z'', z1) -{ 9 + 2*xs'' + 2*y' }-> mapIter(1 + x3 + s'', 1 + log(s4) + z1) :|: s4 >= 0, s4 <= 1 + y' + xs'' + 1, s'' >= 0, s'' <= 1 + y' + xs'', z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0
   isempty(z') -{ 1 }-> 2 :|: z' = 0
   isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0
   last(z') -{ 4 + xs + y }-> s5 :|: s5 >= 0, s5 <= 1 + y + xs + 1, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   last(z') -{ 1 }-> 1 :|: z' = 0
   last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0
   le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0
   log(z') -{ 1 }-> 2 :|: z' = 0
   log(z') -{ 0 }-> 0 :|: z' >= 0
   loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0
   loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0
   mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0
   maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0

Function symbols to be analyzed: {if,loop}, {log}, {ifmap,mapIter}, {maplog}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [2]
  droplast: runtime: O(n^1) [2 + z'], size: O(n^1) [z']
  double: runtime: O(n^1) [1 + z'], size: O(n^1) [2*z']
  isempty: runtime: O(1) [1], size: O(1) [2]
  last: runtime: O(n^1) [2 + z'], size: O(n^1) [1 + z']
  a: runtime: O(1) [1], size: O(1) [1]

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

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

   a -{ 1 }-> 1 :|: 
   a -{ 1 }-> 0 :|: 
   double(z') -{ 1 }-> 0 :|: z' = 0
   double(z') -{ 0 }-> 0 :|: z' >= 0
   double(z') -{ 1 + z' }-> 1 + (1 + s2) :|: s2 >= 0, s2 <= 2 * (z' - 1), z' - 1 >= 0
   droplast(z') -{ 1 }-> 0 :|: z' = 0
   droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0
   droplast(z') -{ 4 + xs + y }-> 1 + x + s1 :|: s1 >= 0, s1 <= 1 + y + xs, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1
   if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 2 + z1 }-> loop(z'', 1 + (1 + s3), 1 + z2) :|: s3 >= 0, s3 <= 2 * (z1 - 1), z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0
   if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0
   ifmap(z', z'', z1) -{ 9 + 2*xs'' + 2*y' }-> mapIter(1 + x3 + s'', 1 + log(s4) + z1) :|: s4 >= 0, s4 <= 1 + y' + xs'' + 1, s'' >= 0, s'' <= 1 + y' + xs'', z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0
   isempty(z') -{ 1 }-> 2 :|: z' = 0
   isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0
   last(z') -{ 4 + xs + y }-> s5 :|: s5 >= 0, s5 <= 1 + y + xs + 1, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   last(z') -{ 1 }-> 1 :|: z' = 0
   last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0
   le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0
   log(z') -{ 1 }-> 2 :|: z' = 0
   log(z') -{ 0 }-> 0 :|: z' >= 0
   loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0
   loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0
   mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0
   maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0

Function symbols to be analyzed: {if,loop}, {log}, {ifmap,mapIter}, {maplog}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [2]
  droplast: runtime: O(n^1) [2 + z'], size: O(n^1) [z']
  double: runtime: O(n^1) [1 + z'], size: O(n^1) [2*z']
  isempty: runtime: O(1) [1], size: O(1) [2]
  last: runtime: O(n^1) [2 + z'], size: O(n^1) [1 + z']
  a: runtime: O(1) [1], size: O(1) [1]

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

(57) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

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

   a -{ 1 }-> 1 :|: 
   a -{ 1 }-> 0 :|: 
   double(z') -{ 1 }-> 0 :|: z' = 0
   double(z') -{ 0 }-> 0 :|: z' >= 0
   double(z') -{ 1 + z' }-> 1 + (1 + s2) :|: s2 >= 0, s2 <= 2 * (z' - 1), z' - 1 >= 0
   droplast(z') -{ 1 }-> 0 :|: z' = 0
   droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0
   droplast(z') -{ 4 + xs + y }-> 1 + x + s1 :|: s1 >= 0, s1 <= 1 + y + xs, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1
   if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 2 + z1 }-> loop(z'', 1 + (1 + s3), 1 + z2) :|: s3 >= 0, s3 <= 2 * (z1 - 1), z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0
   if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0
   ifmap(z', z'', z1) -{ 9 + 2*xs'' + 2*y' }-> mapIter(1 + x3 + s'', 1 + log(s4) + z1) :|: s4 >= 0, s4 <= 1 + y' + xs'' + 1, s'' >= 0, s'' <= 1 + y' + xs'', z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0
   isempty(z') -{ 1 }-> 2 :|: z' = 0
   isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0
   last(z') -{ 4 + xs + y }-> s5 :|: s5 >= 0, s5 <= 1 + y + xs + 1, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   last(z') -{ 1 }-> 1 :|: z' = 0
   last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0
   le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0
   log(z') -{ 1 }-> 2 :|: z' = 0
   log(z') -{ 0 }-> 0 :|: z' >= 0
   loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0
   loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0
   mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0
   maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0

Function symbols to be analyzed: {if,loop}, {log}, {ifmap,mapIter}, {maplog}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [2]
  droplast: runtime: O(n^1) [2 + z'], size: O(n^1) [z']
  double: runtime: O(n^1) [1 + z'], size: O(n^1) [2*z']
  isempty: runtime: O(1) [1], size: O(1) [2]
  last: runtime: O(n^1) [2 + z'], size: O(n^1) [1 + z']
  a: runtime: O(1) [1], size: O(1) [1]
  if: runtime: ?, size: INF
  loop: runtime: ?, size: INF

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

(59) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   a -{ 1 }-> 1 :|: 
   a -{ 1 }-> 0 :|: 
   double(z') -{ 1 }-> 0 :|: z' = 0
   double(z') -{ 0 }-> 0 :|: z' >= 0
   double(z') -{ 1 + z' }-> 1 + (1 + s2) :|: s2 >= 0, s2 <= 2 * (z' - 1), z' - 1 >= 0
   droplast(z') -{ 1 }-> 0 :|: z' = 0
   droplast(z') -{ 1 }-> 0 :|: z' - 1 >= 0
   droplast(z') -{ 4 + xs + y }-> 1 + x + s1 :|: s1 >= 0, s1 <= 1 + y + xs, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   if(z', z'', z1, z2) -{ 1 }-> z2 :|: z2 >= 0, z' = 2, z'' >= 0, z1 >= 0
   if(z', z'', z1, z2) -{ 2 }-> loop(z'', 0, 1 + z2) :|: z1 = 0, z2 >= 0, z'' >= 0, z' = 1
   if(z', z'', z1, z2) -{ 1 }-> loop(z'', 0, 1 + z2) :|: z2 >= 0, z'' >= 0, z1 >= 0, z' = 1
   if(z', z'', z1, z2) -{ 2 + z1 }-> loop(z'', 1 + (1 + s3), 1 + z2) :|: s3 >= 0, s3 <= 2 * (z1 - 1), z2 >= 0, z'' >= 0, z' = 1, z1 - 1 >= 0
   if(z', z'', z1, z2) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0, z2 >= 0
   ifmap(z', z'', z1) -{ 1 }-> z1 :|: z'' >= 0, z' = 2, z1 >= 0
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(1) + z1) :|: z'' = 0, z1 >= 0, z' = 1
   ifmap(z', z'', z1) -{ 3 }-> mapIter(0, 1 + log(z'' - 1) + z1) :|: z1 >= 0, z' = 1, z'' - 1 >= 0
   ifmap(z', z'', z1) -{ 9 + 2*xs'' + 2*y' }-> mapIter(1 + x3 + s'', 1 + log(s4) + z1) :|: s4 >= 0, s4 <= 1 + y' + xs'' + 1, s'' >= 0, s'' <= 1 + y' + xs'', z1 >= 0, xs'' >= 0, y' >= 0, z' = 1, z'' = 1 + x3 + (1 + y' + xs''), x3 >= 0
   isempty(z') -{ 1 }-> 2 :|: z' = 0
   isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0
   last(z') -{ 4 + xs + y }-> s5 :|: s5 >= 0, s5 <= 1 + y + xs + 1, xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   last(z') -{ 1 }-> 1 :|: z' = 0
   last(z') -{ 1 }-> z' - 1 :|: z' - 1 >= 0
   le(z', z'') -{ 2 + z'' }-> s :|: s >= 0, s <= 2, z' - 1 >= 0, z'' - 1 >= 0
   le(z', z'') -{ 1 }-> 2 :|: z'' >= 0, z' = 0
   le(z', z'') -{ 1 }-> 1 :|: z'' = 0, z' - 1 >= 0
   le(z', z'') -{ 0 }-> 0 :|: z' >= 0, z'' >= 0
   log(z') -{ 1 }-> loop(1 + (z' - 1), 1 + 0, 0) :|: z' - 1 >= 0
   log(z') -{ 1 }-> 2 :|: z' = 0
   log(z') -{ 0 }-> 0 :|: z' >= 0
   loop(z', z'', z1) -{ 3 + z'' }-> if(s', 1 + (z' - 1), 1 + (z'' - 1), z1) :|: s' >= 0, s' <= 2, z1 >= 0, z' - 1 >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 2 }-> if(2, 0, 1 + (z'' - 1), z1) :|: z1 >= 0, z'' - 1 >= 0, z' = 0
   loop(z', z'', z1) -{ 1 }-> if(0, z', 1 + (z'' - 1), z1) :|: z1 >= 0, z' >= 0, z'' - 1 >= 0
   loop(z', z'', z1) -{ 0 }-> 0 :|: z' >= 0, z'' >= 0, z1 >= 0
   mapIter(z', z'') -{ 2 }-> ifmap(2, 0, z'') :|: z'' >= 0, z' = 0
   mapIter(z', z'') -{ 2 }-> ifmap(1, 1 + x1 + xs', z'') :|: x1 >= 0, z' = 1 + x1 + xs', z'' >= 0, xs' >= 0
   maplog(z') -{ 1 }-> mapIter(z', 0) :|: z' >= 0

Function symbols to be analyzed: {if,loop}, {log}, {ifmap,mapIter}, {maplog}
Previous analysis results are:
  le: runtime: O(n^1) [2 + z''], size: O(1) [2]
  droplast: runtime: O(n^1) [2 + z'], size: O(n^1) [z']
  double: runtime: O(n^1) [1 + z'], size: O(n^1) [2*z']
  isempty: runtime: O(1) [1], size: O(1) [2]
  last: runtime: O(n^1) [2 + z'], size: O(n^1) [1 + z']
  a: runtime: O(1) [1], size: O(1) [1]
  if: runtime: INF, size: INF
  loop: runtime: ?, size: INF

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

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

   le(v0, v1) -> null_le [0]
   double(v0) -> null_double [0]
   log(v0) -> null_log [0]
   loop(v0, v1, v2) -> null_loop [0]
   if(v0, v1, v2, v3) -> null_if [0]
   ifmap(v0, v1, v2) -> null_ifmap [0]
   isempty(v0) -> null_isempty [0]
   last(v0) -> null_last [0]
   droplast(v0) -> null_droplast [0]

And the following fresh constants:    null_le, null_double, null_log, null_loop, null_if, null_ifmap, null_isempty, null_last, null_droplast

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

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

   le(s(x), 0) -> false [1]
   le(0, y) -> true [1]
   le(s(x), s(y)) -> le(x, y) [1]
   double(0) -> 0 [1]
   double(s(x)) -> s(s(double(x))) [1]
   log(0) -> logError [1]
   log(s(x)) -> loop(s(x), s(0), 0) [1]
   loop(x, s(y), z) -> if(le(x, s(y)), x, s(y), z) [1]
   if(true, x, y, z) -> z [1]
   if(false, x, y, z) -> loop(x, double(y), s(z)) [1]
   maplog(xs) -> mapIter(xs, nil) [1]
   mapIter(xs, ys) -> ifmap(isempty(xs), xs, ys) [1]
   ifmap(true, xs, ys) -> ys [1]
   ifmap(false, xs, ys) -> mapIter(droplast(xs), cons(log(last(xs)), ys)) [1]
   isempty(nil) -> true [1]
   isempty(cons(x, xs)) -> false [1]
   last(nil) -> error [1]
   last(cons(x, nil)) -> x [1]
   last(cons(x, cons(y, xs))) -> last(cons(y, xs)) [1]
   droplast(nil) -> nil [1]
   droplast(cons(x, nil)) -> nil [1]
   droplast(cons(x, cons(y, xs))) -> cons(x, droplast(cons(y, xs))) [1]
   a -> b [1]
   a -> c [1]
   le(v0, v1) -> null_le [0]
   double(v0) -> null_double [0]
   log(v0) -> null_log [0]
   loop(v0, v1, v2) -> null_loop [0]
   if(v0, v1, v2, v3) -> null_if [0]
   ifmap(v0, v1, v2) -> null_ifmap [0]
   isempty(v0) -> null_isempty [0]
   last(v0) -> null_last [0]
   droplast(v0) -> null_droplast [0]

The TRS has the following type information:
le :: s:0:logError:error:null_double:null_log:null_loop:null_if:null_last -> s:0:logError:error:null_double:null_log:null_loop:null_if:null_last -> false:true:null_le:null_isempty
s :: s:0:logError:error:null_double:null_log:null_loop:null_if:null_last -> s:0:logError:error:null_double:null_log:null_loop:null_if:null_last
0 :: s:0:logError:error:null_double:null_log:null_loop:null_if:null_last
false :: false:true:null_le:null_isempty
true :: false:true:null_le:null_isempty
double :: s:0:logError:error:null_double:null_log:null_loop:null_if:null_last -> s:0:logError:error:null_double:null_log:null_loop:null_if:null_last
log :: s:0:logError:error:null_double:null_log:null_loop:null_if:null_last -> s:0:logError:error:null_double:null_log:null_loop:null_if:null_last
logError :: s:0:logError:error:null_double:null_log:null_loop:null_if:null_last
loop :: s:0:logError:error:null_double:null_log:null_loop:null_if:null_last -> s:0:logError:error:null_double:null_log:null_loop:null_if:null_last -> s:0:logError:error:null_double:null_log:null_loop:null_if:null_last -> s:0:logError:error:null_double:null_log:null_loop:null_if:null_last
if :: false:true:null_le:null_isempty -> s:0:logError:error:null_double:null_log:null_loop:null_if:null_last -> s:0:logError:error:null_double:null_log:null_loop:null_if:null_last -> s:0:logError:error:null_double:null_log:null_loop:null_if:null_last -> s:0:logError:error:null_double:null_log:null_loop:null_if:null_last
maplog :: nil:cons:null_ifmap:null_droplast -> nil:cons:null_ifmap:null_droplast
mapIter :: nil:cons:null_ifmap:null_droplast -> nil:cons:null_ifmap:null_droplast -> nil:cons:null_ifmap:null_droplast
nil :: nil:cons:null_ifmap:null_droplast
ifmap :: false:true:null_le:null_isempty -> nil:cons:null_ifmap:null_droplast -> nil:cons:null_ifmap:null_droplast -> nil:cons:null_ifmap:null_droplast
isempty :: nil:cons:null_ifmap:null_droplast -> false:true:null_le:null_isempty
droplast :: nil:cons:null_ifmap:null_droplast -> nil:cons:null_ifmap:null_droplast
cons :: s:0:logError:error:null_double:null_log:null_loop:null_if:null_last -> nil:cons:null_ifmap:null_droplast -> nil:cons:null_ifmap:null_droplast
last :: nil:cons:null_ifmap:null_droplast -> s:0:logError:error:null_double:null_log:null_loop:null_if:null_last
error :: s:0:logError:error:null_double:null_log:null_loop:null_if:null_last
a :: b:c
b :: b:c
c :: b:c
null_le :: false:true:null_le:null_isempty
null_double :: s:0:logError:error:null_double:null_log:null_loop:null_if:null_last
null_log :: s:0:logError:error:null_double:null_log:null_loop:null_if:null_last
null_loop :: s:0:logError:error:null_double:null_log:null_loop:null_if:null_last
null_if :: s:0:logError:error:null_double:null_log:null_loop:null_if:null_last
null_ifmap :: nil:cons:null_ifmap:null_droplast
null_isempty :: false:true:null_le:null_isempty
null_last :: s:0:logError:error:null_double:null_log:null_loop:null_if:null_last
null_droplast :: nil:cons:null_ifmap:null_droplast

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

(63) 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
   false => 1
   true => 2
   logError => 2
   nil => 0
   error => 1
   b => 0
   c => 1
   null_le => 0
   null_double => 0
   null_log => 0
   null_loop => 0
   null_if => 0
   null_ifmap => 0
   null_isempty => 0
   null_last => 0
   null_droplast => 0

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

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

   a -{ 1 }-> 1 :|: 
   a -{ 1 }-> 0 :|: 
   double(z') -{ 1 }-> 0 :|: z' = 0
   double(z') -{ 0 }-> 0 :|: v0 >= 0, z' = v0
   double(z') -{ 1 }-> 1 + (1 + double(x)) :|: z' = 1 + x, x >= 0
   droplast(z') -{ 1 }-> 0 :|: z' = 0
   droplast(z') -{ 1 }-> 0 :|: x >= 0, z' = 1 + x + 0
   droplast(z') -{ 0 }-> 0 :|: v0 >= 0, z' = v0
   droplast(z') -{ 1 }-> 1 + x + droplast(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   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 }-> loop(x, double(y), 1 + 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
   ifmap(z', z'', z1) -{ 1 }-> ys :|: xs >= 0, z' = 2, ys >= 0, z'' = xs, z1 = ys
   ifmap(z', z'', z1) -{ 1 }-> mapIter(droplast(xs), 1 + log(last(xs)) + ys) :|: xs >= 0, ys >= 0, z'' = xs, z' = 1, z1 = ys
   ifmap(z', z'', z1) -{ 0 }-> 0 :|: v0 >= 0, z1 = v2, v1 >= 0, z'' = v1, v2 >= 0, z' = v0
   isempty(z') -{ 1 }-> 2 :|: z' = 0
   isempty(z') -{ 1 }-> 1 :|: xs >= 0, z' = 1 + x + xs, x >= 0
   isempty(z') -{ 0 }-> 0 :|: v0 >= 0, z' = v0
   last(z') -{ 1 }-> x :|: x >= 0, z' = 1 + x + 0
   last(z') -{ 1 }-> last(1 + y + xs) :|: xs >= 0, z' = 1 + x + (1 + y + xs), x >= 0, y >= 0
   last(z') -{ 1 }-> 1 :|: z' = 0
   last(z') -{ 0 }-> 0 :|: v0 >= 0, z' = v0
   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
   log(z') -{ 1 }-> loop(1 + x, 1 + 0, 0) :|: z' = 1 + x, x >= 0
   log(z') -{ 1 }-> 2 :|: z' = 0
   log(z') -{ 0 }-> 0 :|: v0 >= 0, z' = v0
   loop(z', z'', z1) -{ 1 }-> if(le(x, 1 + y), x, 1 + y, z) :|: z1 = z, z >= 0, z' = x, x >= 0, y >= 0, z'' = 1 + y
   loop(z', z'', z1) -{ 0 }-> 0 :|: v0 >= 0, z1 = v2, v1 >= 0, z'' = v1, v2 >= 0, z' = v0
   mapIter(z', z'') -{ 1 }-> ifmap(isempty(xs), xs, ys) :|: xs >= 0, ys >= 0, z'' = ys, z' = xs
   maplog(z') -{ 1 }-> mapIter(xs, 0) :|: xs >= 0, z' = xs

Only complete derivations are relevant for the runtime complexity.

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

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

(66)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(s(z0), 0) -> false
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   maplog(z0) -> mapIter(z0, nil)
   mapIter(z0, z1) -> ifmap(isempty(z0), z0, z1)
   ifmap(true, z0, z1) -> z1
   ifmap(false, z0, z1) -> mapIter(droplast(z0), cons(log(last(z0)), z1))
   isempty(nil) -> true
   isempty(cons(z0, z1)) -> false
   last(nil) -> error
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   droplast(nil) -> nil
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   a -> b
   a -> c
Tuples:
   LE(s(z0), 0) -> c1
   LE(0, z0) -> c2
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(0) -> c4
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(0) -> c6
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LOOP(z0, s(z1), z2) -> c8(IF(le(z0, s(z1)), z0, s(z1), z2), LE(z0, s(z1)))
   IF(true, z0, z1, z2) -> c9
   IF(false, z0, z1, z2) -> c10(LOOP(z0, double(z1), s(z2)), DOUBLE(z1))
   MAPLOG(z0) -> c11(MAPITER(z0, nil))
   MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1), ISEMPTY(z0))
   IFMAP(true, z0, z1) -> c13
   IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0))
   IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0))
   ISEMPTY(nil) -> c16
   ISEMPTY(cons(z0, z1)) -> c17
   LAST(nil) -> c18
   LAST(cons(z0, nil)) -> c19
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(nil) -> c21
   DROPLAST(cons(z0, nil)) -> c22
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   A -> c24
   A -> c25
S tuples:
   LE(s(z0), 0) -> c1
   LE(0, z0) -> c2
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(0) -> c4
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(0) -> c6
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LOOP(z0, s(z1), z2) -> c8(IF(le(z0, s(z1)), z0, s(z1), z2), LE(z0, s(z1)))
   IF(true, z0, z1, z2) -> c9
   IF(false, z0, z1, z2) -> c10(LOOP(z0, double(z1), s(z2)), DOUBLE(z1))
   MAPLOG(z0) -> c11(MAPITER(z0, nil))
   MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1), ISEMPTY(z0))
   IFMAP(true, z0, z1) -> c13
   IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0))
   IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0))
   ISEMPTY(nil) -> c16
   ISEMPTY(cons(z0, z1)) -> c17
   LAST(nil) -> c18
   LAST(cons(z0, nil)) -> c19
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(nil) -> c21
   DROPLAST(cons(z0, nil)) -> c22
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   A -> c24
   A -> c25
K tuples:none
Defined Rule Symbols:   le_2, double_1, log_1, loop_3, if_4, maplog_1, mapIter_2, ifmap_3, isempty_1, last_1, droplast_1, a

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LOOP_3, IF_4, MAPLOG_1, MAPITER_2, IFMAP_3, ISEMPTY_1, LAST_1, DROPLAST_1, A

Compound Symbols:   c1, c2, c3_1, c4, c5_1, c6, c7_1, c8_2, c9, c10_2, c11_1, c12_2, c13, c14_2, c15_3, c16, c17, c18, c19, c20_1, c21, c22, c23_1, c24, c25


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

(67) CdtLeafRemovalProof (ComplexityIfPolyImplication)
Removed 1 leading nodes:
   MAPLOG(z0) -> c11(MAPITER(z0, nil))
Removed 14 trailing nodes:
   IF(true, z0, z1, z2) -> c9
   ISEMPTY(nil) -> c16
   DOUBLE(0) -> c4
   A -> c25
   ISEMPTY(cons(z0, z1)) -> c17
   LE(s(z0), 0) -> c1
   DROPLAST(cons(z0, nil)) -> c22
   LAST(nil) -> c18
   LOG(0) -> c6
   IFMAP(true, z0, z1) -> c13
   DROPLAST(nil) -> c21
   LE(0, z0) -> c2
   A -> c24
   LAST(cons(z0, nil)) -> c19

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

(68)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(s(z0), 0) -> false
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   maplog(z0) -> mapIter(z0, nil)
   mapIter(z0, z1) -> ifmap(isempty(z0), z0, z1)
   ifmap(true, z0, z1) -> z1
   ifmap(false, z0, z1) -> mapIter(droplast(z0), cons(log(last(z0)), z1))
   isempty(nil) -> true
   isempty(cons(z0, z1)) -> false
   last(nil) -> error
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   droplast(nil) -> nil
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   a -> b
   a -> c
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LOOP(z0, s(z1), z2) -> c8(IF(le(z0, s(z1)), z0, s(z1), z2), LE(z0, s(z1)))
   IF(false, z0, z1, z2) -> c10(LOOP(z0, double(z1), s(z2)), DOUBLE(z1))
   MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1), ISEMPTY(z0))
   IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0))
   IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LOOP(z0, s(z1), z2) -> c8(IF(le(z0, s(z1)), z0, s(z1), z2), LE(z0, s(z1)))
   IF(false, z0, z1, z2) -> c10(LOOP(z0, double(z1), s(z2)), DOUBLE(z1))
   MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1), ISEMPTY(z0))
   IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0))
   IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
K tuples:none
Defined Rule Symbols:   le_2, double_1, log_1, loop_3, if_4, maplog_1, mapIter_2, ifmap_3, isempty_1, last_1, droplast_1, a

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LOOP_3, IF_4, MAPITER_2, IFMAP_3, LAST_1, DROPLAST_1

Compound Symbols:   c3_1, c5_1, c7_1, c8_2, c10_2, c12_2, c14_2, c15_3, c20_1, c23_1


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

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

(70)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(s(z0), 0) -> false
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   maplog(z0) -> mapIter(z0, nil)
   mapIter(z0, z1) -> ifmap(isempty(z0), z0, z1)
   ifmap(true, z0, z1) -> z1
   ifmap(false, z0, z1) -> mapIter(droplast(z0), cons(log(last(z0)), z1))
   isempty(nil) -> true
   isempty(cons(z0, z1)) -> false
   last(nil) -> error
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   droplast(nil) -> nil
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   a -> b
   a -> c
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LOOP(z0, s(z1), z2) -> c8(IF(le(z0, s(z1)), z0, s(z1), z2), LE(z0, s(z1)))
   IF(false, z0, z1, z2) -> c10(LOOP(z0, double(z1), s(z2)), DOUBLE(z1))
   IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0))
   IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LOOP(z0, s(z1), z2) -> c8(IF(le(z0, s(z1)), z0, s(z1), z2), LE(z0, s(z1)))
   IF(false, z0, z1, z2) -> c10(LOOP(z0, double(z1), s(z2)), DOUBLE(z1))
   IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0))
   IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1))
K tuples:none
Defined Rule Symbols:   le_2, double_1, log_1, loop_3, if_4, maplog_1, mapIter_2, ifmap_3, isempty_1, last_1, droplast_1, a

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LOOP_3, IF_4, IFMAP_3, LAST_1, DROPLAST_1, MAPITER_2

Compound Symbols:   c3_1, c5_1, c7_1, c8_2, c10_2, c14_2, c15_3, c20_1, c23_1, c12_1


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

(71) CdtUsableRulesProof (BOTH BOUNDS(ID, ID))
The following rules are not usable and were removed:
   maplog(z0) -> mapIter(z0, nil)
   mapIter(z0, z1) -> ifmap(isempty(z0), z0, z1)
   ifmap(true, z0, z1) -> z1
   ifmap(false, z0, z1) -> mapIter(droplast(z0), cons(log(last(z0)), z1))
   a -> b
   a -> c

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

(72)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(nil) -> nil
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(nil) -> error
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   isempty(nil) -> true
   isempty(cons(z0, z1)) -> false
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LOOP(z0, s(z1), z2) -> c8(IF(le(z0, s(z1)), z0, s(z1), z2), LE(z0, s(z1)))
   IF(false, z0, z1, z2) -> c10(LOOP(z0, double(z1), s(z2)), DOUBLE(z1))
   IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0))
   IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LOOP(z0, s(z1), z2) -> c8(IF(le(z0, s(z1)), z0, s(z1), z2), LE(z0, s(z1)))
   IF(false, z0, z1, z2) -> c10(LOOP(z0, double(z1), s(z2)), DOUBLE(z1))
   IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0))
   IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1))
K tuples:none
Defined Rule Symbols:   le_2, double_1, droplast_1, log_1, last_1, loop_3, if_4, isempty_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LOOP_3, IF_4, IFMAP_3, LAST_1, DROPLAST_1, MAPITER_2

Compound Symbols:   c3_1, c5_1, c7_1, c8_2, c10_2, c14_2, c15_3, c20_1, c23_1, c12_1


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

(73) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace LOOP(z0, s(z1), z2) -> c8(IF(le(z0, s(z1)), z0, s(z1), z2), LE(z0, s(z1))) by 
   LOOP(0, s(x1), x2) -> c8(IF(true, 0, s(x1), x2), LE(0, s(x1)))
   LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1)))

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

(74)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(nil) -> nil
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(nil) -> error
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   isempty(nil) -> true
   isempty(cons(z0, z1)) -> false
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   IF(false, z0, z1, z2) -> c10(LOOP(z0, double(z1), s(z2)), DOUBLE(z1))
   IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0))
   IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1))
   LOOP(0, s(x1), x2) -> c8(IF(true, 0, s(x1), x2), LE(0, s(x1)))
   LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   IF(false, z0, z1, z2) -> c10(LOOP(z0, double(z1), s(z2)), DOUBLE(z1))
   IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0))
   IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1))
   LOOP(0, s(x1), x2) -> c8(IF(true, 0, s(x1), x2), LE(0, s(x1)))
   LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1)))
K tuples:none
Defined Rule Symbols:   le_2, double_1, droplast_1, log_1, last_1, loop_3, if_4, isempty_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, IF_4, IFMAP_3, LAST_1, DROPLAST_1, MAPITER_2, LOOP_3

Compound Symbols:   c3_1, c5_1, c7_1, c10_2, c14_2, c15_3, c20_1, c23_1, c12_1, c8_2


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

(75) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   LOOP(0, s(x1), x2) -> c8(IF(true, 0, s(x1), x2), LE(0, s(x1)))

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

(76)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(nil) -> nil
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(nil) -> error
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   isempty(nil) -> true
   isempty(cons(z0, z1)) -> false
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   IF(false, z0, z1, z2) -> c10(LOOP(z0, double(z1), s(z2)), DOUBLE(z1))
   IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0))
   IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1))
   LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   IF(false, z0, z1, z2) -> c10(LOOP(z0, double(z1), s(z2)), DOUBLE(z1))
   IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0))
   IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1))
   LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1)))
K tuples:none
Defined Rule Symbols:   le_2, double_1, droplast_1, log_1, last_1, loop_3, if_4, isempty_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, IF_4, IFMAP_3, LAST_1, DROPLAST_1, MAPITER_2, LOOP_3

Compound Symbols:   c3_1, c5_1, c7_1, c10_2, c14_2, c15_3, c20_1, c23_1, c12_1, c8_2


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

(77) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IF(false, z0, z1, z2) -> c10(LOOP(z0, double(z1), s(z2)), DOUBLE(z1)) by 
   IF(false, x0, 0, x2) -> c10(LOOP(x0, 0, s(x2)), DOUBLE(0))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))

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

(78)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(nil) -> nil
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(nil) -> error
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   isempty(nil) -> true
   isempty(cons(z0, z1)) -> false
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0))
   IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1))
   LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1)))
   IF(false, x0, 0, x2) -> c10(LOOP(x0, 0, s(x2)), DOUBLE(0))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0))
   IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1))
   LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1)))
   IF(false, x0, 0, x2) -> c10(LOOP(x0, 0, s(x2)), DOUBLE(0))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
K tuples:none
Defined Rule Symbols:   le_2, double_1, droplast_1, log_1, last_1, loop_3, if_4, isempty_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, IFMAP_3, LAST_1, DROPLAST_1, MAPITER_2, LOOP_3, IF_4

Compound Symbols:   c3_1, c5_1, c7_1, c14_2, c15_3, c20_1, c23_1, c12_1, c8_2, c10_2


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

(79) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   IF(false, x0, 0, x2) -> c10(LOOP(x0, 0, s(x2)), DOUBLE(0))

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

(80)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(nil) -> nil
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(nil) -> error
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   isempty(nil) -> true
   isempty(cons(z0, z1)) -> false
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0))
   IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1))
   LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0))
   IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1))
   LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
K tuples:none
Defined Rule Symbols:   le_2, double_1, droplast_1, log_1, last_1, loop_3, if_4, isempty_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, IFMAP_3, LAST_1, DROPLAST_1, MAPITER_2, LOOP_3, IF_4

Compound Symbols:   c3_1, c5_1, c7_1, c14_2, c15_3, c20_1, c23_1, c12_1, c8_2, c10_2


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

(81) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, z0, z1) -> c15(MAPITER(droplast(z0), cons(log(last(z0)), z1)), LOG(last(z0)), LAST(z0)) by 
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)), LOG(error), LAST(nil))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0), LAST(cons(z0, nil)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1)))

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

(82)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(nil) -> nil
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(nil) -> error
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   isempty(nil) -> true
   isempty(cons(z0, z1)) -> false
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1))
   LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)), LOG(error), LAST(nil))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0), LAST(cons(z0, nil)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1))
   LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)), LOG(error), LAST(nil))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0), LAST(cons(z0, nil)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1)))
K tuples:none
Defined Rule Symbols:   le_2, double_1, droplast_1, log_1, last_1, loop_3, if_4, isempty_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, IFMAP_3, LAST_1, DROPLAST_1, MAPITER_2, LOOP_3, IF_4

Compound Symbols:   c3_1, c5_1, c7_1, c14_2, c20_1, c23_1, c12_1, c8_2, c10_2, c15_3, c15_1


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

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

(84)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(nil) -> nil
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(nil) -> error
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   isempty(nil) -> true
   isempty(cons(z0, z1)) -> false
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1))
   LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1))
   LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
K tuples:none
Defined Rule Symbols:   le_2, double_1, droplast_1, log_1, last_1, loop_3, if_4, isempty_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, IFMAP_3, LAST_1, DROPLAST_1, MAPITER_2, LOOP_3, IF_4

Compound Symbols:   c3_1, c5_1, c7_1, c14_2, c20_1, c23_1, c12_1, c8_2, c10_2, c15_3, c15_1, c15_2


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

(85) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MAPITER(z0, z1) -> c12(IFMAP(isempty(z0), z0, z1)) by 
   MAPITER(nil, x1) -> c12(IFMAP(true, nil, x1))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))

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

(86)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(nil) -> nil
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(nil) -> error
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   isempty(nil) -> true
   isempty(cons(z0, z1)) -> false
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(nil, x1) -> c12(IFMAP(true, nil, x1))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(nil, x1) -> c12(IFMAP(true, nil, x1))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
K tuples:none
Defined Rule Symbols:   le_2, double_1, droplast_1, log_1, last_1, loop_3, if_4, isempty_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, IFMAP_3, LAST_1, DROPLAST_1, LOOP_3, IF_4, MAPITER_2

Compound Symbols:   c3_1, c5_1, c7_1, c14_2, c20_1, c23_1, c8_2, c10_2, c15_3, c15_1, c15_2, c12_1


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

(87) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   MAPITER(nil, x1) -> c12(IFMAP(true, nil, x1))

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

(88)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(nil) -> nil
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(nil) -> error
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   isempty(nil) -> true
   isempty(cons(z0, z1)) -> false
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
K tuples:none
Defined Rule Symbols:   le_2, double_1, droplast_1, log_1, last_1, loop_3, if_4, isempty_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, IFMAP_3, LAST_1, DROPLAST_1, LOOP_3, IF_4, MAPITER_2

Compound Symbols:   c3_1, c5_1, c7_1, c14_2, c20_1, c23_1, c8_2, c10_2, c15_3, c15_1, c15_2, c12_1


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

(89) CdtKnowledgeProof (BOTH BOUNDS(ID, ID))
The following tuples could be moved from S to K by knowledge propagation:
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))

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

(90)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(nil) -> nil
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(nil) -> error
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   isempty(nil) -> true
   isempty(cons(z0, z1)) -> false
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
K tuples:
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))
Defined Rule Symbols:   le_2, double_1, droplast_1, log_1, last_1, loop_3, if_4, isempty_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, IFMAP_3, LAST_1, DROPLAST_1, LOOP_3, IF_4, MAPITER_2

Compound Symbols:   c3_1, c5_1, c7_1, c14_2, c20_1, c23_1, c8_2, c10_2, c15_3, c15_1, c15_2, c12_1


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

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

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

(92)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   droplast(nil) -> nil
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(nil) -> error
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
K tuples:
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))
Defined Rule Symbols:   droplast_1, log_1, last_1, loop_3, if_4, le_2, double_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, IFMAP_3, LAST_1, DROPLAST_1, LOOP_3, IF_4, MAPITER_2

Compound Symbols:   c3_1, c5_1, c7_1, c14_2, c20_1, c23_1, c8_2, c10_2, c15_3, c15_1, c15_2, c12_1


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

(93) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, z0, z1) -> c14(MAPITER(droplast(z0), cons(log(last(z0)), z1)), DROPLAST(z0)) by 
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)), DROPLAST(nil))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), DROPLAST(cons(z0, nil)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c14(MAPITER(nil, cons(log(last(nil)), x1)), DROPLAST(nil))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(nil, cons(log(last(cons(z0, nil))), x1)), DROPLAST(cons(z0, nil)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))

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

(94)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   droplast(nil) -> nil
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(nil) -> error
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)), DROPLAST(nil))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), DROPLAST(cons(z0, nil)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c14(MAPITER(nil, cons(log(last(nil)), x1)), DROPLAST(nil))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(nil, cons(log(last(cons(z0, nil))), x1)), DROPLAST(cons(z0, nil)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)), DROPLAST(nil))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), DROPLAST(cons(z0, nil)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c14(MAPITER(nil, cons(log(last(nil)), x1)), DROPLAST(nil))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(nil, cons(log(last(cons(z0, nil))), x1)), DROPLAST(cons(z0, nil)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
K tuples:
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))
Defined Rule Symbols:   droplast_1, log_1, last_1, loop_3, if_4, le_2, double_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, LOOP_3, IF_4, IFMAP_3, MAPITER_2

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c8_2, c10_2, c15_3, c15_1, c15_2, c12_1, c14_2


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

(95) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 2 trailing nodes:
   IFMAP(false, nil, x1) -> c14(MAPITER(nil, cons(log(last(nil)), x1)), DROPLAST(nil))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(nil, cons(log(last(cons(z0, nil))), x1)), DROPLAST(cons(z0, nil)))

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

(96)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   droplast(nil) -> nil
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(nil) -> error
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)), DROPLAST(nil))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), DROPLAST(cons(z0, nil)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)), DROPLAST(nil))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), DROPLAST(cons(z0, nil)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
K tuples:
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))
Defined Rule Symbols:   droplast_1, log_1, last_1, loop_3, if_4, le_2, double_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, LOOP_3, IF_4, IFMAP_3, MAPITER_2

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c8_2, c10_2, c15_3, c15_1, c15_2, c12_1, c14_2


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

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

(98)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   droplast(nil) -> nil
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(nil) -> error
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
K tuples:
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))
Defined Rule Symbols:   droplast_1, log_1, last_1, loop_3, if_4, le_2, double_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, LOOP_3, IF_4, IFMAP_3, MAPITER_2

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c8_2, c10_2, c15_3, c15_1, c15_2, c12_1, c14_2, c14_1


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

(99) CdtKnowledgeProof (BOTH BOUNDS(ID, ID))
The following tuples could be moved from S to K by knowledge propagation:
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))

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

(100)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   droplast(nil) -> nil
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(nil) -> error
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
K tuples:
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
Defined Rule Symbols:   droplast_1, log_1, last_1, loop_3, if_4, le_2, double_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, LOOP_3, IF_4, IFMAP_3, MAPITER_2

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c8_2, c10_2, c15_3, c15_1, c15_2, c12_1, c14_2, c14_1


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

(101) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace LOOP(s(z0), s(z1), x2) -> c8(IF(le(z0, z1), s(z0), s(z1), x2), LE(s(z0), s(z1))) by 
   LOOP(s(0), s(z0), x2) -> c8(IF(true, s(0), s(z0), x2), LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(s(z0)), s(0), x2) -> c8(IF(false, s(s(z0)), s(0), x2), LE(s(s(z0)), s(0)))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))

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

(102)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   droplast(nil) -> nil
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(nil) -> error
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(0), s(z0), x2) -> c8(IF(true, s(0), s(z0), x2), LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(s(z0)), s(0), x2) -> c8(IF(false, s(s(z0)), s(0), x2), LE(s(s(z0)), s(0)))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(0), s(z0), x2) -> c8(IF(true, s(0), s(z0), x2), LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(s(z0)), s(0), x2) -> c8(IF(false, s(s(z0)), s(0), x2), LE(s(s(z0)), s(0)))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
K tuples:
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
Defined Rule Symbols:   droplast_1, log_1, last_1, loop_3, if_4, le_2, double_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, IFMAP_3, MAPITER_2, LOOP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c15_3, c15_1, c15_2, c12_1, c14_2, c14_1, c8_2, c8_1


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

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

(104)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   droplast(nil) -> nil
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(nil) -> error
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(s(z0)), s(0), x2) -> c8(IF(false, s(s(z0)), s(0), x2), LE(s(s(z0)), s(0)))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(s(z0)), s(0), x2) -> c8(IF(false, s(s(z0)), s(0), x2), LE(s(s(z0)), s(0)))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
K tuples:
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
Defined Rule Symbols:   droplast_1, log_1, last_1, loop_3, if_4, le_2, double_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, IFMAP_3, MAPITER_2, LOOP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c15_3, c15_1, c15_2, c12_1, c14_2, c14_1, c8_2, c8_1


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

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

(106)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   droplast(nil) -> nil
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(nil) -> error
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
K tuples:
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
Defined Rule Symbols:   droplast_1, log_1, last_1, loop_3, if_4, le_2, double_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, IFMAP_3, MAPITER_2, LOOP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c15_3, c15_1, c15_2, c12_1, c14_2, c14_1, c8_2, c8_1, c_1


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

(107) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) by 
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))

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

(108)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   droplast(nil) -> nil
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(nil) -> error
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
K tuples:
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
Defined Rule Symbols:   droplast_1, log_1, last_1, loop_3, if_4, le_2, double_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, IFMAP_3, MAPITER_2, LOOP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c15_1, c15_2, c12_1, c14_2, c14_1, c8_2, c8_1, c_1, c15_3


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

(109) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, x0, x1) -> c15(MAPITER(droplast(x0), cons(log(last(x0)), x1))) by 
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, nil, x1) -> c15(MAPITER(nil, cons(log(last(nil)), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(nil, cons(log(last(cons(z0, nil))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))

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

(110)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   droplast(nil) -> nil
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(nil) -> error
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, nil, x1) -> c15(MAPITER(nil, cons(log(last(nil)), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(nil, cons(log(last(cons(z0, nil))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, nil, x1) -> c15(MAPITER(nil, cons(log(last(nil)), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(nil, cons(log(last(cons(z0, nil))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
K tuples:
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
Defined Rule Symbols:   droplast_1, log_1, last_1, loop_3, if_4, le_2, double_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, IFMAP_3, MAPITER_2, LOOP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c15_1, c15_2, c12_1, c14_2, c14_1, c8_2, c8_1, c_1, c15_3


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

(111) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 2 trailing nodes:
   IFMAP(false, nil, x1) -> c15(MAPITER(nil, cons(log(last(nil)), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(nil, cons(log(last(cons(z0, nil))), x1)))

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

(112)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   droplast(nil) -> nil
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(nil) -> error
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
K tuples:
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
Defined Rule Symbols:   droplast_1, log_1, last_1, loop_3, if_4, le_2, double_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, IFMAP_3, MAPITER_2, LOOP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c15_1, c15_2, c12_1, c14_2, c14_1, c8_2, c8_1, c_1, c15_3


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

(113) CdtKnowledgeProof (BOTH BOUNDS(ID, ID))
The following tuples could be moved from S to K by knowledge propagation:
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))

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

(114)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   droplast(nil) -> nil
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(nil) -> error
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
K tuples:
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
Defined Rule Symbols:   droplast_1, log_1, last_1, loop_3, if_4, le_2, double_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, IFMAP_3, MAPITER_2, LOOP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c15_1, c15_2, c12_1, c14_2, c14_1, c8_2, c8_1, c_1, c15_3


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

(115) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1))) by 
   IFMAP(false, nil, x0) -> c15(MAPITER(droplast(nil), cons(log(error), x0)))
   IFMAP(false, nil, x0) -> c15(MAPITER(nil, cons(log(last(nil)), x0)))

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

(116)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   droplast(nil) -> nil
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(nil) -> error
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, nil, x0) -> c15(MAPITER(nil, cons(log(last(nil)), x0)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
K tuples:
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(last(nil)), x1)))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
Defined Rule Symbols:   droplast_1, log_1, last_1, loop_3, if_4, le_2, double_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, IFMAP_3, MAPITER_2, LOOP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c15_2, c12_1, c14_2, c14_1, c8_2, c8_1, c_1, c15_3, c15_1


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

(117) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   IFMAP(false, nil, x0) -> c15(MAPITER(nil, cons(log(last(nil)), x0)))

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

(118)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   droplast(nil) -> nil
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(nil) -> error
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
K tuples:
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
Defined Rule Symbols:   droplast_1, log_1, last_1, loop_3, if_4, le_2, double_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, IFMAP_3, MAPITER_2, LOOP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c15_2, c12_1, c14_2, c14_1, c8_2, c8_1, c_1, c15_3, c15_1


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

(119) CdtUsableRulesProof (BOTH BOUNDS(ID, ID))
The following rules are not usable and were removed:
   last(nil) -> error

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

(120)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   droplast(nil) -> nil
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
K tuples:
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
Defined Rule Symbols:   double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, IFMAP_3, MAPITER_2, LOOP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c15_2, c12_1, c14_2, c14_1, c8_2, c8_1, c_1, c15_3, c15_1


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

(121) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(last(cons(z0, nil))), x1)), LOG(z0)) by 
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(nil, cons(log(last(cons(z0, nil))), x1)), LOG(z0))

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

(122)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   droplast(nil) -> nil
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(nil, cons(log(last(cons(z0, nil))), x1)), LOG(z0))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(nil, cons(log(last(cons(z0, nil))), x1)), LOG(z0))
K tuples:
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
Defined Rule Symbols:   double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, IFMAP_3, LOOP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c14_2, c14_1, c8_2, c8_1, c_1, c15_3, c15_1, c15_2


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

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

(124)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   droplast(nil) -> nil
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
K tuples:
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
Defined Rule Symbols:   double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, IFMAP_3, LOOP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c14_2, c14_1, c8_2, c8_1, c_1, c15_3, c15_1, c15_2


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

(125) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
We considered the (Usable) Rules:
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   droplast(nil) -> nil
And the Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(DOUBLE(x_1)) = 0
   POL(DROPLAST(x_1)) = 0
   POL(IF(x_1, x_2, x_3, x_4)) = x_2 + x_3 + x_4
   POL(IFMAP(x_1, x_2, x_3)) = x_1 + x_2
   POL(LAST(x_1)) = 0
   POL(LE(x_1, x_2)) = 0
   POL(LOG(x_1)) = 0
   POL(LOOP(x_1, x_2, x_3)) = x_3
   POL(MAPITER(x_1, x_2)) = x_1
   POL(c(x_1)) = x_1
   POL(c10(x_1, x_2)) = x_1 + x_2
   POL(c12(x_1)) = x_1
   POL(c14(x_1)) = x_1
   POL(c14(x_1, x_2)) = x_1 + x_2
   POL(c15(x_1)) = x_1
   POL(c15(x_1, x_2)) = x_1 + x_2
   POL(c15(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c20(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c3(x_1)) = x_1
   POL(c5(x_1)) = x_1
   POL(c7(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(c8(x_1, x_2)) = x_1 + x_2
   POL(cons(x_1, x_2)) = x_2
   POL(double(x_1)) = [1] + x_1
   POL(droplast(x_1)) = x_1
   POL(error) = [1]
   POL(false) = 0
   POL(if(x_1, x_2, x_3, x_4)) = [1] + x_1 + x_2 + x_3 + x_4
   POL(last(x_1)) = [1]
   POL(le(x_1, x_2)) = [1] + x_1
   POL(log(x_1)) = [1]
   POL(logError) = [1]
   POL(loop(x_1, x_2, x_3)) = [1] + x_1 + x_2 + x_3
   POL(nil) = [1]
   POL(s(x_1)) = 0
   POL(true) = [1]

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

(126)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   droplast(nil) -> nil
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
K tuples:
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
Defined Rule Symbols:   double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, IFMAP_3, LOOP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c14_2, c14_1, c8_2, c8_1, c_1, c15_3, c15_1, c15_2


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

(127) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) by 
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))

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

(128)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   droplast(nil) -> nil
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
K tuples:
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
Defined Rule Symbols:   double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, IFMAP_3, LOOP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c14_2, c14_1, c8_2, c8_1, c_1, c15_3, c15_1, c15_2


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

(129) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)), DROPLAST(cons(z0, cons(z1, z2)))) by 
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))

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

(130)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   droplast(nil) -> nil
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
K tuples:
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
Defined Rule Symbols:   double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, IFMAP_3, LOOP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c14_1, c8_2, c8_1, c_1, c15_3, c15_1, c15_2, c14_2


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

(131) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
We considered the (Usable) Rules:
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   droplast(nil) -> nil
And the Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(DOUBLE(x_1)) = 0
   POL(DROPLAST(x_1)) = 0
   POL(IF(x_1, x_2, x_3, x_4)) = x_2 + x_3 + x_4
   POL(IFMAP(x_1, x_2, x_3)) = x_1 + x_2
   POL(LAST(x_1)) = 0
   POL(LE(x_1, x_2)) = 0
   POL(LOG(x_1)) = 0
   POL(LOOP(x_1, x_2, x_3)) = x_3
   POL(MAPITER(x_1, x_2)) = x_1
   POL(c(x_1)) = x_1
   POL(c10(x_1, x_2)) = x_1 + x_2
   POL(c12(x_1)) = x_1
   POL(c14(x_1)) = x_1
   POL(c14(x_1, x_2)) = x_1 + x_2
   POL(c15(x_1)) = x_1
   POL(c15(x_1, x_2)) = x_1 + x_2
   POL(c15(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c20(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c3(x_1)) = x_1
   POL(c5(x_1)) = x_1
   POL(c7(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(c8(x_1, x_2)) = x_1 + x_2
   POL(cons(x_1, x_2)) = [1] + x_2
   POL(double(x_1)) = [1] + x_1
   POL(droplast(x_1)) = x_1
   POL(error) = [1]
   POL(false) = 0
   POL(if(x_1, x_2, x_3, x_4)) = [1] + x_1 + x_2 + x_3 + x_4
   POL(last(x_1)) = [1]
   POL(le(x_1, x_2)) = [1] + x_1
   POL(log(x_1)) = [1]
   POL(logError) = [1]
   POL(loop(x_1, x_2, x_3)) = [1] + x_1 + x_2 + x_3
   POL(nil) = 0
   POL(s(x_1)) = 0
   POL(true) = [1]

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

(132)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   droplast(nil) -> nil
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
K tuples:
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
Defined Rule Symbols:   double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, IFMAP_3, LOOP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c14_1, c8_2, c8_1, c_1, c15_3, c15_1, c15_2, c14_2


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

(133) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1))) by 
   IFMAP(false, nil, x0) -> c14(MAPITER(nil, cons(log(error), x0)))

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

(134)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   droplast(nil) -> nil
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, nil, x0) -> c14(MAPITER(nil, cons(log(error), x0)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
K tuples:
   IFMAP(false, nil, x1) -> c14(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
Defined Rule Symbols:   double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, IFMAP_3, LOOP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c14_1, c8_2, c8_1, c_1, c15_3, c15_1, c15_2, c14_2


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

(135) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   IFMAP(false, nil, x0) -> c14(MAPITER(nil, cons(log(error), x0)))

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

(136)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   droplast(nil) -> nil
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
K tuples:
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
Defined Rule Symbols:   double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, IFMAP_3, LOOP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c14_1, c8_2, c8_1, c_1, c15_3, c15_1, c15_2, c14_2


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

(137) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) by 
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(nil, cons(log(z0), x1)))

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

(138)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   droplast(nil) -> nil
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(nil, cons(log(z0), x1)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(nil, cons(log(z0), x1)))
K tuples:
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
Defined Rule Symbols:   double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_2, c8_1, c_1, c15_3, c15_1, c15_2, c14_2, c14_1


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

(139) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   IFMAP(false, cons(z0, nil), x1) -> c14(MAPITER(nil, cons(log(z0), x1)))

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

(140)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   droplast(nil) -> nil
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1))))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
K tuples:
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
Defined Rule Symbols:   double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_2, c8_1, c_1, c15_3, c15_1, c15_2, c14_2, c14_1


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

(141) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace LOOP(s(s(z0)), s(s(z1)), x2) -> c8(IF(le(z0, z1), s(s(z0)), s(s(z1)), x2), LE(s(s(z0)), s(s(z1)))) by 
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(IF(true, s(s(0)), s(s(z0)), x2), LE(s(s(0)), s(s(z0))))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))

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

(142)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   droplast(nil) -> nil
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(IF(true, s(s(0)), s(s(z0)), x2), LE(s(s(0)), s(s(z0))))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(IF(true, s(s(0)), s(s(z0)), x2), LE(s(s(0)), s(s(z0))))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
K tuples:
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
Defined Rule Symbols:   double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_3, c15_1, c15_2, c14_2, c14_1, c8_2


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

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

(144)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   droplast(nil) -> nil
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
K tuples:
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
Defined Rule Symbols:   double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_3, c15_1, c15_2, c14_2, c14_1, c8_2


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

(145) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) by 
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))

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

(146)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   droplast(nil) -> nil
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
K tuples:
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
Defined Rule Symbols:   double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_3, c15_1, c15_2, c14_2, c14_1, c8_2


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

(147) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) by 
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))

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

(148)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   droplast(nil) -> nil
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
K tuples:
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
Defined Rule Symbols:   double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c15_2, c14_2, c14_1, c8_2, c15_3


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

(149) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
We considered the (Usable) Rules:
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   droplast(nil) -> nil
And the Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(DOUBLE(x_1)) = 0
   POL(DROPLAST(x_1)) = 0
   POL(IF(x_1, x_2, x_3, x_4)) = x_2 + x_3 + x_4
   POL(IFMAP(x_1, x_2, x_3)) = [1] + x_1 + x_2
   POL(LAST(x_1)) = 0
   POL(LE(x_1, x_2)) = 0
   POL(LOG(x_1)) = 0
   POL(LOOP(x_1, x_2, x_3)) = x_3
   POL(MAPITER(x_1, x_2)) = [1] + x_1
   POL(c(x_1)) = x_1
   POL(c10(x_1, x_2)) = x_1 + x_2
   POL(c12(x_1)) = x_1
   POL(c14(x_1)) = x_1
   POL(c14(x_1, x_2)) = x_1 + x_2
   POL(c15(x_1)) = x_1
   POL(c15(x_1, x_2)) = x_1 + x_2
   POL(c15(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c20(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c3(x_1)) = x_1
   POL(c5(x_1)) = x_1
   POL(c7(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(c8(x_1, x_2)) = x_1 + x_2
   POL(cons(x_1, x_2)) = [1] + x_2
   POL(double(x_1)) = [1] + x_1
   POL(droplast(x_1)) = x_1
   POL(error) = [1]
   POL(false) = 0
   POL(if(x_1, x_2, x_3, x_4)) = [1] + x_1 + x_2 + x_3 + x_4
   POL(last(x_1)) = [1]
   POL(le(x_1, x_2)) = [1] + x_1
   POL(log(x_1)) = [1]
   POL(logError) = [1]
   POL(loop(x_1, x_2, x_3)) = [1] + x_1 + x_3
   POL(nil) = 0
   POL(s(x_1)) = 0
   POL(true) = [1]

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

(150)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   droplast(nil) -> nil
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
K tuples:
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
Defined Rule Symbols:   double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c15_2, c14_2, c14_1, c8_2, c15_3


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

(151) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1))) by 
   IFMAP(false, nil, x0) -> c15(MAPITER(nil, cons(log(error), x0)))

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

(152)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   droplast(nil) -> nil
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, nil, x0) -> c15(MAPITER(nil, cons(log(error), x0)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
K tuples:
   IFMAP(false, nil, x1) -> c15(MAPITER(droplast(nil), cons(log(error), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
Defined Rule Symbols:   double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c15_2, c14_2, c14_1, c8_2, c15_3


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

(153) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   IFMAP(false, nil, x0) -> c15(MAPITER(nil, cons(log(error), x0)))

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

(154)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   droplast(nil) -> nil
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
Defined Rule Symbols:   double_1, droplast_1, log_1, last_1, loop_3, if_4, le_2

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c15_2, c14_2, c14_1, c8_2, c15_3


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

(155) CdtUsableRulesProof (BOTH BOUNDS(ID, ID))
The following rules are not usable and were removed:
   droplast(nil) -> nil

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

(156)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c15_2, c14_2, c14_1, c8_2, c15_3


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

(157) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1))) by 
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(nil, cons(log(z0), x1)))

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

(158)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(nil, cons(log(z0), x1)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(nil, cons(log(z0), x1)))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c15_2, c14_2, c14_1, c8_2, c15_3


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

(159) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(nil, cons(log(z0), x1)))

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

(160)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c15_2, c14_2, c14_1, c8_2, c15_3


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

(161) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(droplast(cons(z0, cons(z1, z2))), cons(log(last(cons(z1, z2))), x1))) by 
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))

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

(162)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c15_2, c14_2, c14_1, c8_2, c15_3


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

(163) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(z0, cons(z1, z2)), x1) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z0, cons(z1, z2)))), x1))) by 
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))

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

(164)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_2, c15_1, c14_2, c14_1, c8_2, c15_3


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

(165) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
We considered the (Usable) Rules:
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
And the Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(DOUBLE(x_1)) = 0
   POL(DROPLAST(x_1)) = 0
   POL(IF(x_1, x_2, x_3, x_4)) = x_2 + x_3 + x_4
   POL(IFMAP(x_1, x_2, x_3)) = x_1 + x_2
   POL(LAST(x_1)) = 0
   POL(LE(x_1, x_2)) = 0
   POL(LOG(x_1)) = 0
   POL(LOOP(x_1, x_2, x_3)) = x_3
   POL(MAPITER(x_1, x_2)) = x_1
   POL(c(x_1)) = x_1
   POL(c10(x_1, x_2)) = x_1 + x_2
   POL(c12(x_1)) = x_1
   POL(c14(x_1)) = x_1
   POL(c14(x_1, x_2)) = x_1 + x_2
   POL(c15(x_1)) = x_1
   POL(c15(x_1, x_2)) = x_1 + x_2
   POL(c15(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c20(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c3(x_1)) = x_1
   POL(c5(x_1)) = x_1
   POL(c7(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(c8(x_1, x_2)) = x_1 + x_2
   POL(cons(x_1, x_2)) = [1] + x_2
   POL(double(x_1)) = [1] + x_1
   POL(droplast(x_1)) = x_1
   POL(false) = 0
   POL(if(x_1, x_2, x_3, x_4)) = [1] + x_1 + x_2 + x_3 + x_4
   POL(last(x_1)) = [1] + x_1
   POL(le(x_1, x_2)) = [1] + x_1
   POL(log(x_1)) = [1]
   POL(logError) = [1]
   POL(loop(x_1, x_2, x_3)) = [1] + x_1 + x_3
   POL(nil) = 0
   POL(s(x_1)) = 0
   POL(true) = [1]

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

(166)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_2, c15_1, c14_2, c14_1, c8_2, c15_3


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

(167) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(droplast(cons(z0, nil)), cons(log(z0), x1)), LOG(z0)) by 
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)), LOG(0))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(nil, cons(log(z0), x1)), LOG(z0))

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

(168)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)), LOG(0))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(nil, cons(log(z0), x1)), LOG(z0))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)), LOG(0))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(MAPITER(nil, cons(log(z0), x1)), LOG(z0))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c14_1, c8_2, c15_3, c15_2


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

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

(170)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c14_1, c8_2, c15_3, c15_2


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

(171) CdtKnowledgeProof (BOTH BOUNDS(ID, ID))
The following tuples could be moved from S to K by knowledge propagation:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))

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

(172)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c14_1, c8_2, c15_3, c15_2


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

(173) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), DROPLAST(cons(x0, cons(z0, nil)))) by 
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))

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

(174)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c14_1, c8_2, c15_3, c15_2


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

(175) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) by 
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))

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

(176)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c14_1, c8_2, c15_3, c15_2


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

(177) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil)))) by 
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))

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

(178)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c14_1, c8_2, c15_3, c15_2


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

(179) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c14(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), DROPLAST(cons(x0, cons(z0, cons(z1, z2))))) by 
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))

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

(180)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c14_1, c8_2, c15_3, c15_2


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

(181) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
We considered the (Usable) Rules:
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
And the Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(DOUBLE(x_1)) = 0
   POL(DROPLAST(x_1)) = 0
   POL(IF(x_1, x_2, x_3, x_4)) = 0
   POL(IFMAP(x_1, x_2, x_3)) = x_1 + x_2
   POL(LAST(x_1)) = 0
   POL(LE(x_1, x_2)) = 0
   POL(LOG(x_1)) = 0
   POL(LOOP(x_1, x_2, x_3)) = 0
   POL(MAPITER(x_1, x_2)) = x_1
   POL(c(x_1)) = x_1
   POL(c10(x_1, x_2)) = x_1 + x_2
   POL(c12(x_1)) = x_1
   POL(c14(x_1)) = x_1
   POL(c14(x_1, x_2)) = x_1 + x_2
   POL(c15(x_1)) = x_1
   POL(c15(x_1, x_2)) = x_1 + x_2
   POL(c15(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c20(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c3(x_1)) = x_1
   POL(c5(x_1)) = x_1
   POL(c7(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(c8(x_1, x_2)) = x_1 + x_2
   POL(cons(x_1, x_2)) = [1] + x_1 + x_2
   POL(double(x_1)) = [1] + x_1
   POL(droplast(x_1)) = x_1
   POL(false) = 0
   POL(if(x_1, x_2, x_3, x_4)) = [1] + x_1 + x_2 + x_3 + x_4
   POL(last(x_1)) = [1] + x_1
   POL(le(x_1, x_2)) = [1] + x_1
   POL(log(x_1)) = [1]
   POL(logError) = [1]
   POL(loop(x_1, x_2, x_3)) = [1] + x_1 + x_3
   POL(nil) = 0
   POL(s(x_1)) = [1]
   POL(true) = [1]

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

(182)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c14_1, c8_2, c15_3, c15_2


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

(183) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(0, nil), x1) -> c14(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) by 
   IFMAP(false, cons(0, nil), x0) -> c14(MAPITER(nil, cons(logError, x0)))

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

(184)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(0, nil), x0) -> c14(MAPITER(nil, cons(logError, x0)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(0, nil), x0) -> c14(MAPITER(nil, cons(logError, x0)))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c14(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c14_1, c8_2, c15_3, c15_2


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

(185) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   IFMAP(false, cons(0, nil), x0) -> c14(MAPITER(nil, cons(logError, x0)))

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

(186)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c14_1, c8_2, c15_3, c15_2


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

(187) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(s(z0), nil), x1) -> c14(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) by 
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(nil, cons(loop(s(x0), s(0), 0), x1)))

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

(188)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(nil, cons(loop(s(x0), s(0), 0), x1)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(nil, cons(loop(s(x0), s(0), 0), x1)))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_3, c15_2, c14_1


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

(189) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(nil, cons(loop(s(x0), s(0), 0), x1)))

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

(190)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1)))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_3, c15_2, c14_1


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

(191) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace LOOP(s(s(s(z0))), s(s(s(z1))), x2) -> c8(IF(le(z0, z1), s(s(s(z0))), s(s(s(z1))), x2), LE(s(s(s(z0))), s(s(s(z1))))) by 
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(IF(true, s(s(s(0))), s(s(s(z0))), x2), LE(s(s(s(0))), s(s(s(z0)))))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))

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

(192)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(IF(true, s(s(s(0))), s(s(s(z0))), x2), LE(s(s(s(0))), s(s(s(z0)))))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(IF(true, s(s(s(0))), s(s(s(z0))), x2), LE(s(s(s(0))), s(s(s(z0)))))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_3, c15_2, c14_1


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

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

(194)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_3, c15_2, c14_1


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

(195) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) by 
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))

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

(196)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_3, c15_2, c14_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.
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
We considered the (Usable) Rules:
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
And the Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(DOUBLE(x_1)) = 0
   POL(DROPLAST(x_1)) = 0
   POL(IF(x_1, x_2, x_3, x_4)) = x_2 + x_3 + x_4
   POL(IFMAP(x_1, x_2, x_3)) = x_1 + x_2
   POL(LAST(x_1)) = 0
   POL(LE(x_1, x_2)) = 0
   POL(LOG(x_1)) = 0
   POL(LOOP(x_1, x_2, x_3)) = x_3
   POL(MAPITER(x_1, x_2)) = x_1
   POL(c(x_1)) = x_1
   POL(c10(x_1, x_2)) = x_1 + x_2
   POL(c12(x_1)) = x_1
   POL(c14(x_1)) = x_1
   POL(c14(x_1, x_2)) = x_1 + x_2
   POL(c15(x_1)) = x_1
   POL(c15(x_1, x_2)) = x_1 + x_2
   POL(c15(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c20(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c3(x_1)) = x_1
   POL(c5(x_1)) = x_1
   POL(c7(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(c8(x_1, x_2)) = x_1 + x_2
   POL(cons(x_1, x_2)) = x_2
   POL(double(x_1)) = [1] + x_1
   POL(droplast(x_1)) = x_1
   POL(false) = 0
   POL(if(x_1, x_2, x_3, x_4)) = [1] + x_2 + x_3 + x_4
   POL(last(x_1)) = [1] + x_1
   POL(le(x_1, x_2)) = 0
   POL(log(x_1)) = [1]
   POL(logError) = [1]
   POL(loop(x_1, x_2, x_3)) = [1] + x_3
   POL(nil) = [1]
   POL(s(x_1)) = 0
   POL(true) = [1]

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

(198)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_3, c15_2, c14_1


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

(199) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) by 
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))

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

(200)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_3, c15_2, c14_1


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

(201) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
We considered the (Usable) Rules:none
And the Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(DOUBLE(x_1)) = 0
   POL(DROPLAST(x_1)) = 0
   POL(IF(x_1, x_2, x_3, x_4)) = 0
   POL(IFMAP(x_1, x_2, x_3)) = [1] + [3]x_1 + x_2
   POL(LAST(x_1)) = 0
   POL(LE(x_1, x_2)) = 0
   POL(LOG(x_1)) = 0
   POL(LOOP(x_1, x_2, x_3)) = 0
   POL(MAPITER(x_1, x_2)) = [2]
   POL(c(x_1)) = x_1
   POL(c10(x_1, x_2)) = x_1 + x_2
   POL(c12(x_1)) = x_1
   POL(c14(x_1)) = x_1
   POL(c14(x_1, x_2)) = x_1 + x_2
   POL(c15(x_1)) = x_1
   POL(c15(x_1, x_2)) = x_1 + x_2
   POL(c15(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c20(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c3(x_1)) = x_1
   POL(c5(x_1)) = x_1
   POL(c7(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(c8(x_1, x_2)) = x_1 + x_2
   POL(cons(x_1, x_2)) = [1]
   POL(double(x_1)) = [3]x_1
   POL(droplast(x_1)) = 0
   POL(false) = 0
   POL(if(x_1, x_2, x_3, x_4)) = [3] + [3]x_2 + [3]x_3 + [3]x_4
   POL(last(x_1)) = 0
   POL(le(x_1, x_2)) = 0
   POL(log(x_1)) = [3]
   POL(logError) = [3]
   POL(loop(x_1, x_2, x_3)) = 0
   POL(nil) = 0
   POL(s(x_1)) = 0
   POL(true) = [3]

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

(202)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_3, c15_2, c14_1


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

(203) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), LOG(last(cons(z1, z2))), LAST(cons(z0, cons(z1, z2)))) by 
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))

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

(204)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_3, c15_2, c14_1


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

(205) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil)))) by 
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))

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

(206)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_3, c15_2, c14_1


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

(207) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)), LOG(last(cons(z0, cons(z1, z2)))), LAST(cons(x0, cons(z0, cons(z1, z2))))) by 
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))

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

(208)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_2, c14_1, c15_3


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

(209) CdtKnowledgeProof (BOTH BOUNDS(ID, ID))
The following tuples could be moved from S to K by knowledge propagation:
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))

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

(210)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_2, c14_1, c15_3


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

(211) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
We considered the (Usable) Rules:
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
And the Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(DOUBLE(x_1)) = 0
   POL(DROPLAST(x_1)) = 0
   POL(IF(x_1, x_2, x_3, x_4)) = x_2 + x_3 + x_4
   POL(IFMAP(x_1, x_2, x_3)) = x_1 + x_2
   POL(LAST(x_1)) = 0
   POL(LE(x_1, x_2)) = 0
   POL(LOG(x_1)) = 0
   POL(LOOP(x_1, x_2, x_3)) = x_3
   POL(MAPITER(x_1, x_2)) = x_1
   POL(c(x_1)) = x_1
   POL(c10(x_1, x_2)) = x_1 + x_2
   POL(c12(x_1)) = x_1
   POL(c14(x_1)) = x_1
   POL(c14(x_1, x_2)) = x_1 + x_2
   POL(c15(x_1)) = x_1
   POL(c15(x_1, x_2)) = x_1 + x_2
   POL(c15(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c20(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c3(x_1)) = x_1
   POL(c5(x_1)) = x_1
   POL(c7(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(c8(x_1, x_2)) = x_1 + x_2
   POL(cons(x_1, x_2)) = [1] + x_2
   POL(double(x_1)) = [1] + x_1
   POL(droplast(x_1)) = x_1
   POL(false) = 0
   POL(if(x_1, x_2, x_3, x_4)) = [1] + x_2 + x_3 + x_4
   POL(last(x_1)) = [1] + x_1
   POL(le(x_1, x_2)) = 0
   POL(log(x_1)) = [1]
   POL(logError) = [1]
   POL(loop(x_1, x_2, x_3)) = [1] + x_3
   POL(nil) = 0
   POL(s(x_1)) = 0
   POL(true) = [1]

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

(212)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_2, c14_1, c15_3


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

(213) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) by 
   IFMAP(false, cons(0, nil), x0) -> c15(MAPITER(nil, cons(logError, x0)))

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

(214)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(0, nil), x0) -> c15(MAPITER(nil, cons(logError, x0)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(0, nil), x0) -> c15(MAPITER(nil, cons(logError, x0)))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)), LOG(last(cons(z0, nil))), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_2, c14_1, c15_3


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

(215) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   IFMAP(false, cons(0, nil), x0) -> c15(MAPITER(nil, cons(logError, x0)))

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

(216)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_2, c14_1, c15_3


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

(217) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1))) by 
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(nil, cons(loop(s(x0), s(0), 0), x1)))

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

(218)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(nil, cons(loop(s(x0), s(0), 0), x1)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(nil, cons(loop(s(x0), s(0), 0), x1)))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_2, c14_1, c15_3


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

(219) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(nil, cons(loop(s(x0), s(0), 0), x1)))

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

(220)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_2, c14_1, c15_3


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

(221) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, nil))), cons(log(z0), x3))) by 
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))

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

(222)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_2, c14_1, c15_3


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

(223) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(droplast(cons(x0, cons(z0, cons(z1, z2)))), cons(log(last(cons(z1, z2))), x3))) by 
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))

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

(224)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_2, c14_1, c15_3


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

(225) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3))) by 
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)))

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

(226)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_2, c14_1, c15_3


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

(227) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, cons(z0, droplast(cons(z1, z2)))), cons(log(last(cons(x0, cons(z0, cons(z1, z2))))), x3))) by 
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)))

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

(228)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_2, c14_1, c15_3


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

(229) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)))
We considered the (Usable) Rules:
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
And the Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(DOUBLE(x_1)) = 0
   POL(DROPLAST(x_1)) = 0
   POL(IF(x_1, x_2, x_3, x_4)) = x_2 + x_3 + x_4
   POL(IFMAP(x_1, x_2, x_3)) = [1] + x_1 + x_2
   POL(LAST(x_1)) = 0
   POL(LE(x_1, x_2)) = 0
   POL(LOG(x_1)) = 0
   POL(LOOP(x_1, x_2, x_3)) = x_3
   POL(MAPITER(x_1, x_2)) = [1] + x_1
   POL(c(x_1)) = x_1
   POL(c10(x_1, x_2)) = x_1 + x_2
   POL(c12(x_1)) = x_1
   POL(c14(x_1)) = x_1
   POL(c14(x_1, x_2)) = x_1 + x_2
   POL(c15(x_1)) = x_1
   POL(c15(x_1, x_2)) = x_1 + x_2
   POL(c15(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c20(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c3(x_1)) = x_1
   POL(c5(x_1)) = x_1
   POL(c7(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(c8(x_1, x_2)) = x_1 + x_2
   POL(cons(x_1, x_2)) = [1] + x_2
   POL(double(x_1)) = [1] + x_1
   POL(droplast(x_1)) = x_1
   POL(false) = 0
   POL(if(x_1, x_2, x_3, x_4)) = [1] + x_2 + x_3 + x_4
   POL(last(x_1)) = [1] + x_1
   POL(le(x_1, x_2)) = 0
   POL(log(x_1)) = [1]
   POL(logError) = [1]
   POL(loop(x_1, x_2, x_3)) = [1] + x_3
   POL(nil) = 0
   POL(s(x_1)) = 0
   POL(true) = [1]

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

(230)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c15_2, c14_1, c15_3


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

(231) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(s(z0), nil), x1) -> c15(MAPITER(droplast(cons(s(z0), nil)), cons(loop(s(z0), s(0), 0), x1)), LOG(s(z0))) by 
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(nil, cons(loop(s(x0), s(0), 0), x1)), LOG(s(x0)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0)))

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

(232)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(nil, cons(loop(s(x0), s(0), 0), x1)), LOG(s(x0)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(nil, cons(loop(s(x0), s(0), 0), x1)), LOG(s(x0)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0)))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c14_1, c15_3, c15_2


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

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

(234)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0)))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c14_1, c15_3, c15_2


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

(235) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0)))
We considered the (Usable) Rules:
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
And the Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0)))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(DOUBLE(x_1)) = 0
   POL(DROPLAST(x_1)) = 0
   POL(IF(x_1, x_2, x_3, x_4)) = 0
   POL(IFMAP(x_1, x_2, x_3)) = x_1 + x_2
   POL(LAST(x_1)) = 0
   POL(LE(x_1, x_2)) = 0
   POL(LOG(x_1)) = 0
   POL(LOOP(x_1, x_2, x_3)) = 0
   POL(MAPITER(x_1, x_2)) = x_1
   POL(c(x_1)) = x_1
   POL(c10(x_1, x_2)) = x_1 + x_2
   POL(c12(x_1)) = x_1
   POL(c14(x_1)) = x_1
   POL(c14(x_1, x_2)) = x_1 + x_2
   POL(c15(x_1)) = x_1
   POL(c15(x_1, x_2)) = x_1 + x_2
   POL(c15(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c20(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c3(x_1)) = x_1
   POL(c5(x_1)) = x_1
   POL(c7(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(c8(x_1, x_2)) = x_1 + x_2
   POL(cons(x_1, x_2)) = x_1
   POL(double(x_1)) = [1] + x_1
   POL(droplast(x_1)) = x_1
   POL(false) = 0
   POL(if(x_1, x_2, x_3, x_4)) = [1] + x_2 + x_3 + x_4
   POL(last(x_1)) = [1] + x_1
   POL(le(x_1, x_2)) = 0
   POL(log(x_1)) = [1]
   POL(logError) = [1]
   POL(loop(x_1, x_2, x_3)) = [1] + x_3
   POL(nil) = 0
   POL(s(x_1)) = [1]
   POL(true) = [1]

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

(236)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0)))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0)))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c14_1, c15_3, c15_2


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

(237) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(0, nil), x1) -> c15(MAPITER(droplast(cons(0, nil)), cons(logError, x1))) by 
   IFMAP(false, cons(0, nil), x0) -> c15(MAPITER(nil, cons(logError, x0)))

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

(238)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0)))
   IFMAP(false, cons(0, nil), x0) -> c15(MAPITER(nil, cons(logError, x0)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0)))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, nil), cons(log(last(cons(x0, cons(z0, nil)))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0)))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c14_1, c15_3, c15_2


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

(239) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   IFMAP(false, cons(0, nil), x0) -> c15(MAPITER(nil, cons(logError, x0)))

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

(240)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0)))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0)))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0)))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c14_1, c15_3, c15_2


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

(241) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil)))) by 
   IFMAP(false, cons(z0, cons(0, nil)), x1) -> c14(MAPITER(cons(z0, droplast(cons(0, nil))), cons(logError, x1)), DROPLAST(cons(z0, cons(0, nil))))

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

(242)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0)))
   IFMAP(false, cons(z0, cons(0, nil)), x1) -> c14(MAPITER(cons(z0, droplast(cons(0, nil))), cons(logError, x1)), DROPLAST(cons(z0, cons(0, nil))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0)))
   IFMAP(false, cons(z0, cons(0, nil)), x1) -> c14(MAPITER(cons(z0, droplast(cons(0, nil))), cons(logError, x1)), DROPLAST(cons(z0, cons(0, nil))))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0)))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c14_1, c15_3, c15_2


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

(243) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil)))) by 
   IFMAP(false, cons(x0, cons(s(x1), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(x1), nil))), cons(if(le(s(x1), s(0)), s(x1), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(x1), nil))))
   IFMAP(false, cons(z0, cons(s(x1), nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(s(x1), nil))), cons(loop(s(x1), s(0), 0), x2)), DROPLAST(cons(z0, cons(s(x1), nil))))

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

(244)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0)))
   IFMAP(false, cons(z0, cons(0, nil)), x1) -> c14(MAPITER(cons(z0, droplast(cons(0, nil))), cons(logError, x1)), DROPLAST(cons(z0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(x1), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(x1), nil))), cons(if(le(s(x1), s(0)), s(x1), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(x1), nil))))
   IFMAP(false, cons(z0, cons(s(x1), nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(s(x1), nil))), cons(loop(s(x1), s(0), 0), x2)), DROPLAST(cons(z0, cons(s(x1), nil))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0)))
   IFMAP(false, cons(z0, cons(0, nil)), x1) -> c14(MAPITER(cons(z0, droplast(cons(0, nil))), cons(logError, x1)), DROPLAST(cons(z0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(x1), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(x1), nil))), cons(if(le(s(x1), s(0)), s(x1), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(x1), nil))))
   IFMAP(false, cons(z0, cons(s(x1), nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(s(x1), nil))), cons(loop(s(x1), s(0), 0), x2)), DROPLAST(cons(z0, cons(s(x1), nil))))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0)))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c14_1, c15_3, c15_2


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

(245) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), DROPLAST(cons(z0, cons(z1, nil)))) by 
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c14(MAPITER(cons(x0, droplast(cons(0, nil))), cons(logError, x2)), DROPLAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c14(MAPITER(cons(x0, droplast(cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x2) -> c14(MAPITER(cons(x0, nil), cons(log(z0), x2)), DROPLAST(cons(x0, cons(z0, nil))))

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

(246)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0)))
   IFMAP(false, cons(z0, cons(0, nil)), x1) -> c14(MAPITER(cons(z0, droplast(cons(0, nil))), cons(logError, x1)), DROPLAST(cons(z0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(x1), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(x1), nil))), cons(if(le(s(x1), s(0)), s(x1), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(x1), nil))))
   IFMAP(false, cons(z0, cons(s(x1), nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(s(x1), nil))), cons(loop(s(x1), s(0), 0), x2)), DROPLAST(cons(z0, cons(s(x1), nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x2) -> c14(MAPITER(cons(x0, nil), cons(log(z0), x2)), DROPLAST(cons(x0, cons(z0, nil))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0)))
   IFMAP(false, cons(z0, cons(0, nil)), x1) -> c14(MAPITER(cons(z0, droplast(cons(0, nil))), cons(logError, x1)), DROPLAST(cons(z0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(x1), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(x1), nil))), cons(if(le(s(x1), s(0)), s(x1), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(x1), nil))))
   IFMAP(false, cons(z0, cons(s(x1), nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(s(x1), nil))), cons(loop(s(x1), s(0), 0), x2)), DROPLAST(cons(z0, cons(s(x1), nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x2) -> c14(MAPITER(cons(x0, nil), cons(log(z0), x2)), DROPLAST(cons(x0, cons(z0, nil))))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0)))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c14_1, c15_3, c15_2


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

(247) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   IFMAP(false, cons(x0, cons(z0, nil)), x2) -> c14(MAPITER(cons(x0, nil), cons(log(z0), x2)), DROPLAST(cons(x0, cons(z0, nil))))
We considered the (Usable) Rules:
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
And the Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0)))
   IFMAP(false, cons(z0, cons(0, nil)), x1) -> c14(MAPITER(cons(z0, droplast(cons(0, nil))), cons(logError, x1)), DROPLAST(cons(z0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(x1), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(x1), nil))), cons(if(le(s(x1), s(0)), s(x1), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(x1), nil))))
   IFMAP(false, cons(z0, cons(s(x1), nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(s(x1), nil))), cons(loop(s(x1), s(0), 0), x2)), DROPLAST(cons(z0, cons(s(x1), nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x2) -> c14(MAPITER(cons(x0, nil), cons(log(z0), x2)), DROPLAST(cons(x0, cons(z0, nil))))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(DOUBLE(x_1)) = 0
   POL(DROPLAST(x_1)) = 0
   POL(IF(x_1, x_2, x_3, x_4)) = x_2 + x_3 + x_4
   POL(IFMAP(x_1, x_2, x_3)) = x_1 + x_2
   POL(LAST(x_1)) = 0
   POL(LE(x_1, x_2)) = 0
   POL(LOG(x_1)) = 0
   POL(LOOP(x_1, x_2, x_3)) = x_3
   POL(MAPITER(x_1, x_2)) = x_1
   POL(c(x_1)) = x_1
   POL(c10(x_1, x_2)) = x_1 + x_2
   POL(c12(x_1)) = x_1
   POL(c14(x_1)) = x_1
   POL(c14(x_1, x_2)) = x_1 + x_2
   POL(c15(x_1)) = x_1
   POL(c15(x_1, x_2)) = x_1 + x_2
   POL(c15(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c20(x_1)) = x_1
   POL(c23(x_1)) = x_1
   POL(c3(x_1)) = x_1
   POL(c5(x_1)) = x_1
   POL(c7(x_1)) = x_1
   POL(c8(x_1)) = x_1
   POL(c8(x_1, x_2)) = x_1 + x_2
   POL(cons(x_1, x_2)) = [1] + x_2
   POL(double(x_1)) = [1] + x_1
   POL(droplast(x_1)) = x_1
   POL(false) = 0
   POL(if(x_1, x_2, x_3, x_4)) = [1] + x_2 + x_3 + x_4
   POL(last(x_1)) = [1] + x_1
   POL(le(x_1, x_2)) = 0
   POL(log(x_1)) = [1]
   POL(logError) = [1]
   POL(loop(x_1, x_2, x_3)) = [1] + x_3
   POL(nil) = 0
   POL(s(x_1)) = 0
   POL(true) = [1]

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

(248)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0)))
   IFMAP(false, cons(z0, cons(0, nil)), x1) -> c14(MAPITER(cons(z0, droplast(cons(0, nil))), cons(logError, x1)), DROPLAST(cons(z0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(x1), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(x1), nil))), cons(if(le(s(x1), s(0)), s(x1), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(x1), nil))))
   IFMAP(false, cons(z0, cons(s(x1), nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(s(x1), nil))), cons(loop(s(x1), s(0), 0), x2)), DROPLAST(cons(z0, cons(s(x1), nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x2) -> c14(MAPITER(cons(x0, nil), cons(log(z0), x2)), DROPLAST(cons(x0, cons(z0, nil))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0)))
   IFMAP(false, cons(z0, cons(0, nil)), x1) -> c14(MAPITER(cons(z0, droplast(cons(0, nil))), cons(logError, x1)), DROPLAST(cons(z0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(x1), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(x1), nil))), cons(if(le(s(x1), s(0)), s(x1), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(x1), nil))))
   IFMAP(false, cons(z0, cons(s(x1), nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(s(x1), nil))), cons(loop(s(x1), s(0), 0), x2)), DROPLAST(cons(z0, cons(s(x1), nil))))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0)))
   IFMAP(false, cons(x0, cons(z0, nil)), x2) -> c14(MAPITER(cons(x0, nil), cons(log(z0), x2)), DROPLAST(cons(x0, cons(z0, nil))))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c14_1, c15_3, c15_2


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

(249) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil))))) by 
   IFMAP(false, cons(x0, cons(x1, cons(0, nil))), x3) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(0, nil)))), cons(logError, x3)), DROPLAST(cons(x0, cons(x1, cons(0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(s(z0), nil))), x3) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(s(z0), nil)))), cons(loop(s(z0), s(0), 0), x3)), DROPLAST(cons(x0, cons(x1, cons(s(z0), nil)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, nil))), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, nil)))), cons(log(x2), x3)), DROPLAST(cons(z0, cons(z1, cons(x2, nil)))))

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

(250)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0)))
   IFMAP(false, cons(z0, cons(0, nil)), x1) -> c14(MAPITER(cons(z0, droplast(cons(0, nil))), cons(logError, x1)), DROPLAST(cons(z0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(x1), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(x1), nil))), cons(if(le(s(x1), s(0)), s(x1), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(x1), nil))))
   IFMAP(false, cons(z0, cons(s(x1), nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(s(x1), nil))), cons(loop(s(x1), s(0), 0), x2)), DROPLAST(cons(z0, cons(s(x1), nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x2) -> c14(MAPITER(cons(x0, nil), cons(log(z0), x2)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(0, nil))), x3) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(0, nil)))), cons(logError, x3)), DROPLAST(cons(x0, cons(x1, cons(0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(s(z0), nil))), x3) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(s(z0), nil)))), cons(loop(s(z0), s(0), 0), x3)), DROPLAST(cons(x0, cons(x1, cons(s(z0), nil)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, nil))), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, nil)))), cons(log(x2), x3)), DROPLAST(cons(z0, cons(z1, cons(x2, nil)))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0)))
   IFMAP(false, cons(z0, cons(0, nil)), x1) -> c14(MAPITER(cons(z0, droplast(cons(0, nil))), cons(logError, x1)), DROPLAST(cons(z0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(x1), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(x1), nil))), cons(if(le(s(x1), s(0)), s(x1), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(x1), nil))))
   IFMAP(false, cons(z0, cons(s(x1), nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(s(x1), nil))), cons(loop(s(x1), s(0), 0), x2)), DROPLAST(cons(z0, cons(s(x1), nil))))
   IFMAP(false, cons(x0, cons(x1, cons(0, nil))), x3) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(0, nil)))), cons(logError, x3)), DROPLAST(cons(x0, cons(x1, cons(0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(s(z0), nil))), x3) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(s(z0), nil)))), cons(loop(s(z0), s(0), 0), x3)), DROPLAST(cons(x0, cons(x1, cons(s(z0), nil)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, nil))), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, nil)))), cons(log(x2), x3)), DROPLAST(cons(z0, cons(z1, cons(x2, nil)))))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0)))
   IFMAP(false, cons(x0, cons(z0, nil)), x2) -> c14(MAPITER(cons(x0, nil), cons(log(z0), x2)), DROPLAST(cons(x0, cons(z0, nil))))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c14_1, c15_3, c15_2


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

(251) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))) by 
   IFMAP(false, cons(x0, cons(x1, cons(x2, cons(z0, nil)))), x5) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(x2, cons(z0, nil))))), cons(log(z0), x5)), DROPLAST(cons(x0, cons(x1, cons(x2, cons(z0, nil))))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, cons(z0, cons(z1, z2))))), x5) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(x2, cons(z0, cons(z1, z2)))))), cons(log(last(cons(z1, z2))), x5)), DROPLAST(cons(x0, cons(x1, cons(x2, cons(z0, cons(z1, z2)))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, cons(x3, x4)))), x5) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, cons(x3, x4))))), cons(log(last(cons(x3, x4))), x5)), DROPLAST(cons(z0, cons(z1, cons(x2, cons(x3, x4))))))

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

(252)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   double(0) -> 0
   double(s(z0)) -> s(s(double(z0)))
   droplast(cons(z0, nil)) -> nil
   droplast(cons(z0, cons(z1, z2))) -> cons(z0, droplast(cons(z1, z2)))
   log(0) -> logError
   log(s(z0)) -> loop(s(z0), s(0), 0)
   loop(z0, s(z1), z2) -> if(le(z0, s(z1)), z0, s(z1), z2)
   if(true, z0, z1, z2) -> z2
   if(false, z0, z1, z2) -> loop(z0, double(z1), s(z2))
   le(0, z0) -> true
   le(s(z0), s(z1)) -> le(z0, z1)
   le(s(z0), 0) -> false
   last(cons(z0, nil)) -> z0
   last(cons(z0, cons(z1, z2))) -> last(cons(z1, z2))
Tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c14(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), DROPLAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, nil), cons(log(last(cons(z1, nil))), x2)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0)))
   IFMAP(false, cons(z0, cons(0, nil)), x1) -> c14(MAPITER(cons(z0, droplast(cons(0, nil))), cons(logError, x1)), DROPLAST(cons(z0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(x1), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(x1), nil))), cons(if(le(s(x1), s(0)), s(x1), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(x1), nil))))
   IFMAP(false, cons(z0, cons(s(x1), nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(s(x1), nil))), cons(loop(s(x1), s(0), 0), x2)), DROPLAST(cons(z0, cons(s(x1), nil))))
   IFMAP(false, cons(x0, cons(z0, nil)), x2) -> c14(MAPITER(cons(x0, nil), cons(log(z0), x2)), DROPLAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(0, nil))), x3) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(0, nil)))), cons(logError, x3)), DROPLAST(cons(x0, cons(x1, cons(0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(s(z0), nil))), x3) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(s(z0), nil)))), cons(loop(s(z0), s(0), 0), x3)), DROPLAST(cons(x0, cons(x1, cons(s(z0), nil)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, nil))), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, nil)))), cons(log(x2), x3)), DROPLAST(cons(z0, cons(z1, cons(x2, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, cons(z0, nil)))), x5) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(x2, cons(z0, nil))))), cons(log(z0), x5)), DROPLAST(cons(x0, cons(x1, cons(x2, cons(z0, nil))))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, cons(z0, cons(z1, z2))))), x5) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(x2, cons(z0, cons(z1, z2)))))), cons(log(last(cons(z1, z2))), x5)), DROPLAST(cons(x0, cons(x1, cons(x2, cons(z0, cons(z1, z2)))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, cons(x3, x4)))), x5) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, cons(x3, x4))))), cons(log(last(cons(x3, x4))), x5)), DROPLAST(cons(z0, cons(z1, cons(x2, cons(x3, x4))))))
S tuples:
   LE(s(z0), s(z1)) -> c3(LE(z0, z1))
   DOUBLE(s(z0)) -> c5(DOUBLE(z0))
   LOG(s(z0)) -> c7(LOOP(s(z0), s(0), 0))
   LAST(cons(z0, cons(z1, z2))) -> c20(LAST(cons(z1, z2)))
   DROPLAST(cons(z0, cons(z1, z2))) -> c23(DROPLAST(cons(z1, z2)))
   IF(false, x0, s(z0), x2) -> c10(LOOP(x0, s(s(double(z0))), s(x2)), DOUBLE(s(z0)))
   MAPITER(cons(z0, z1), x1) -> c12(IFMAP(false, cons(z0, z1), x1))
   LOOP(s(x0), s(x1), x2) -> c8(LE(s(x0), s(x1)))
   LOOP(s(0), s(z0), x2) -> c8(LE(s(0), s(z0)))
   LOOP(s(s(z0)), s(0), x2) -> c(IF(false, s(s(z0)), s(0), x2))
   LOOP(s(s(z0)), s(0), x2) -> c(LE(s(s(z0)), s(0)))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)), DROPLAST(cons(z0, cons(z1, z2))))
   LOOP(s(s(s(z0))), s(s(0)), x2) -> c8(IF(false, s(s(s(z0))), s(s(0)), x2), LE(s(s(s(z0))), s(s(0))))
   LOOP(s(s(x0)), s(s(x1)), x2) -> c8(LE(s(s(x0)), s(s(x1))))
   LOOP(s(s(0)), s(s(z0)), x2) -> c8(LE(s(s(0)), s(s(z0))))
   IFMAP(false, cons(z0, cons(z1, z2)), x3) -> c15(MAPITER(cons(z0, droplast(cons(z1, z2))), cons(log(last(cons(z1, z2))), x3)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c14(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), DROPLAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c14(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c14(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   LOOP(s(s(s(s(z0)))), s(s(s(s(z1)))), x2) -> c8(IF(le(z0, z1), s(s(s(s(z0)))), s(s(s(s(z1)))), x2), LE(s(s(s(s(z0)))), s(s(s(s(z1))))))
   LOOP(s(s(s(s(z0)))), s(s(s(0))), x2) -> c8(IF(false, s(s(s(s(z0)))), s(s(s(0))), x2), LE(s(s(s(s(z0)))), s(s(s(0)))))
   LOOP(s(s(s(x0))), s(s(s(x1))), x2) -> c8(LE(s(s(s(x0))), s(s(s(x1)))))
   LOOP(s(s(s(0))), s(s(s(z0))), x2) -> c8(LE(s(s(s(0))), s(s(s(z0)))))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)), LOG(last(cons(0, nil))), LAST(cons(x0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)), LOG(last(cons(s(z0), nil))), LAST(cons(x0, cons(s(z0), nil))))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)), LOG(last(cons(z1, nil))), LAST(cons(z0, cons(z1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(z0, nil)), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, nil))), cons(log(last(cons(z0, nil))), x3)), LOG(z0), LAST(cons(x0, cons(z0, nil))))
   IFMAP(false, cons(x0, cons(z0, cons(z1, z2))), x3) -> c15(MAPITER(cons(x0, droplast(cons(z0, cons(z1, z2)))), cons(log(last(cons(z0, cons(z1, z2)))), x3)), LOG(last(cons(z1, z2))), LAST(cons(x0, cons(z0, cons(z1, z2)))))
   IFMAP(false, cons(x0, cons(x1, x2)), x3) -> c15(MAPITER(cons(x0, droplast(cons(x1, x2))), cons(log(last(cons(x1, x2))), x3)), LAST(cons(x0, cons(x1, x2))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)), LOG(last(cons(z1, cons(x2, x3)))), LAST(cons(z0, cons(z1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)), LOG(last(cons(x1, cons(z0, cons(z1, z2))))), LAST(cons(x0, cons(x1, cons(z0, cons(z1, z2))))))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)))
   IFMAP(false, cons(x0, cons(0, nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(0, nil))), cons(logError, x2)))
   IFMAP(false, cons(x0, cons(s(z0), nil)), x2) -> c15(MAPITER(droplast(cons(x0, cons(s(z0), nil))), cons(loop(s(z0), s(0), 0), x2)))
   IFMAP(false, cons(z0, cons(z1, nil)), x2) -> c15(MAPITER(cons(z0, droplast(cons(z1, nil))), cons(log(z1), x2)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, nil)))), cons(log(z0), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(droplast(cons(x0, cons(x1, cons(z0, cons(z1, z2))))), cons(log(last(cons(z1, z2))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, droplast(cons(z1, cons(x2, x3)))), cons(log(last(cons(x2, x3))), x4)))
   IFMAP(false, cons(z0, cons(z1, cons(x2, x3))), x4) -> c15(MAPITER(cons(z0, cons(z1, droplast(cons(x2, x3)))), cons(log(last(cons(z1, cons(x2, x3)))), x4)))
   IFMAP(false, cons(x0, cons(x1, cons(z0, cons(z1, z2)))), x4) -> c15(MAPITER(cons(x0, cons(x1, cons(z0, droplast(cons(z1, z2))))), cons(log(last(cons(x0, cons(x1, cons(z0, cons(z1, z2)))))), x4)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(MAPITER(droplast(cons(s(x0), nil)), cons(if(le(s(x0), s(0)), s(x0), s(0), 0), x1)), LOG(s(x0)))
   IFMAP(false, cons(z0, cons(0, nil)), x1) -> c14(MAPITER(cons(z0, droplast(cons(0, nil))), cons(logError, x1)), DROPLAST(cons(z0, cons(0, nil))))
   IFMAP(false, cons(x0, cons(s(x1), nil)), x2) -> c14(MAPITER(droplast(cons(x0, cons(s(x1), nil))), cons(if(le(s(x1), s(0)), s(x1), s(0), 0), x2)), DROPLAST(cons(x0, cons(s(x1), nil))))
   IFMAP(false, cons(z0, cons(s(x1), nil)), x2) -> c14(MAPITER(cons(z0, droplast(cons(s(x1), nil))), cons(loop(s(x1), s(0), 0), x2)), DROPLAST(cons(z0, cons(s(x1), nil))))
   IFMAP(false, cons(x0, cons(x1, cons(0, nil))), x3) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(0, nil)))), cons(logError, x3)), DROPLAST(cons(x0, cons(x1, cons(0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(s(z0), nil))), x3) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(s(z0), nil)))), cons(loop(s(z0), s(0), 0), x3)), DROPLAST(cons(x0, cons(x1, cons(s(z0), nil)))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, nil))), x3) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, nil)))), cons(log(x2), x3)), DROPLAST(cons(z0, cons(z1, cons(x2, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, cons(z0, nil)))), x5) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(x2, cons(z0, nil))))), cons(log(z0), x5)), DROPLAST(cons(x0, cons(x1, cons(x2, cons(z0, nil))))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, cons(z0, cons(z1, z2))))), x5) -> c14(MAPITER(droplast(cons(x0, cons(x1, cons(x2, cons(z0, cons(z1, z2)))))), cons(log(last(cons(z1, z2))), x5)), DROPLAST(cons(x0, cons(x1, cons(x2, cons(z0, cons(z1, z2)))))))
   IFMAP(false, cons(z0, cons(z1, cons(x2, cons(x3, x4)))), x5) -> c14(MAPITER(cons(z0, droplast(cons(z1, cons(x2, cons(x3, x4))))), cons(log(last(cons(x3, x4))), x5)), DROPLAST(cons(z0, cons(z1, cons(x2, cons(x3, x4))))))
K tuples:
   IFMAP(false, cons(z0, nil), x1) -> c15(LOG(z0))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c14(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), DROPLAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, nil)), x2) -> c15(LOG(last(cons(x1, nil))))
   IFMAP(false, cons(x0, cons(x1, cons(x2, x3))), x4) -> c15(LOG(last(cons(x1, cons(x2, x3)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)), LOG(last(cons(x1, cons(z0, nil)))), LAST(cons(x0, cons(x1, cons(z0, nil)))))
   IFMAP(false, cons(x0, cons(x1, cons(z0, nil))), x4) -> c15(MAPITER(cons(x0, cons(x1, nil)), cons(log(last(cons(x0, cons(x1, cons(z0, nil))))), x4)))
   IFMAP(false, cons(s(x0), nil), x1) -> c15(LOG(s(x0)))
   IFMAP(false, cons(x0, cons(z0, nil)), x2) -> c14(MAPITER(cons(x0, nil), cons(log(z0), x2)), DROPLAST(cons(x0, cons(z0, nil))))
Defined Rule Symbols:   double_1, droplast_1, log_1, loop_3, if_4, le_2, last_1

Defined Pair Symbols:   LE_2, DOUBLE_1, LOG_1, LAST_1, DROPLAST_1, IF_4, MAPITER_2, LOOP_3, IFMAP_3

Compound Symbols:   c3_1, c5_1, c7_1, c20_1, c23_1, c10_2, c12_1, c8_1, c_1, c15_1, c14_2, c8_2, c14_1, c15_3, c15_2