/export/starexec/sandbox/solver/bin/starexec_run_rcdcRelativeAlsoLower /export/starexec/sandbox/benchmark/theBenchmark.xml /export/starexec/sandbox/output/output_files


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


KILLED
proof of /export/starexec/sandbox/benchmark/theBenchmark.xml
# AProVE Commit ID: 794c25de1cacf0d048858bcd21c9a779e1221865 marcel 20200619 unpublished dirty


The Derivational Complexity (innermost) of the given DCpxTrs could be proven to be BOUNDS(1, INF).

(0) DCpxTrs
(1) DerivationalComplexityToRuntimeComplexityProof [BOTH BOUNDS(ID, ID), 0 ms]
(2) CpxRelTRS
(3) SInnermostTerminationProof [BOTH CONCRETE BOUNDS(ID, ID), 195 ms]
(4) CpxRelTRS
(5) RelTrsToDecreasingLoopProblemProof [LOWER BOUND(ID), 0 ms]
(6) TRS for Loop Detection
(7) RenamingProof [BOTH BOUNDS(ID, ID), 0 ms]
(8) CpxRelTRS
    (9) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
    (10) typed CpxTrs
    (11) OrderProof [LOWER BOUND(ID), 3 ms]
    (12) typed CpxTrs
    (13) RewriteLemmaProof [LOWER BOUND(ID), 5296 ms]
    (14) BOUNDS(1, INF)
(15) RelTrsToTrsProof [UPPER BOUND(ID), 0 ms]
(16) CpxTRS
(17) NonCtorToCtorProof [UPPER BOUND(ID), 0 ms]
(18) CpxRelTRS
    (19) RelTrsToWeightedTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (20) CpxWeightedTrs
    (21) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
    (22) CpxTypedWeightedTrs
    (23) CompletionProof [UPPER BOUND(ID), 0 ms]
    (24) CpxTypedWeightedCompleteTrs
        (25) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 13 ms]
        (26) CpxRNTS
    (27) CompletionProof [UPPER BOUND(ID), 0 ms]
    (28) CpxTypedWeightedCompleteTrs
        (29) NarrowingProof [BOTH BOUNDS(ID, ID), 4 ms]
        (30) CpxTypedWeightedCompleteTrs
        (31) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
        (32) CpxRNTS
        (33) SimplificationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (34) CpxRNTS
(35) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms]
(36) CdtProblem
    (37) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms]
    (38) CdtProblem
    (39) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (40) CdtProblem
    (41) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (42) CdtProblem
    (43) CdtLeafRemovalProof [ComplexityIfPolyImplication, 0 ms]
    (44) CdtProblem
    (45) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 4 ms]
    (46) CdtProblem
    (47) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 105 ms]
    (48) CdtProblem
    (49) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 10 ms]
    (50) CdtProblem
    (51) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (52) CdtProblem
    (53) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (54) CdtProblem
    (55) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 5 ms]
    (56) CdtProblem
    (57) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (58) CdtProblem
    (59) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (60) CdtProblem
    (61) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (62) CdtProblem
    (63) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 50 ms]
    (64) CdtProblem
    (65) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (66) CdtProblem
    (67) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 17 ms]
    (68) CdtProblem
    (69) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 45 ms]
    (70) CdtProblem
    (71) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 7 ms]
    (72) CdtProblem
    (73) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (74) CdtProblem
    (75) CdtRhsSimplificationProcessorProof [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) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (82) CdtProblem
    (83) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 21 ms]
    (84) CdtProblem
    (85) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (86) CdtProblem
    (87) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (88) CdtProblem
    (89) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 4 ms]
    (90) CdtProblem
    (91) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (92) CdtProblem
    (93) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (94) CdtProblem
    (95) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (96) CdtProblem
    (97) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (98) CdtProblem
    (99) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (100) CdtProblem
    (101) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (102) CdtProblem
    (103) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (104) CdtProblem
    (105) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (106) CdtProblem
    (107) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (108) CdtProblem
    (109) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (110) CdtProblem
    (111) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (112) CdtProblem
    (113) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (114) CdtProblem
    (115) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (116) CdtProblem
    (117) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (118) CdtProblem
    (119) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 3 ms]
    (120) CdtProblem
    (121) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (122) CdtProblem
    (123) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (124) CdtProblem
    (125) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (126) CdtProblem
    (127) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (128) CdtProblem
    (129) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (130) CdtProblem
    (131) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 23 ms]
    (132) CdtProblem
    (133) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (134) CdtProblem
    (135) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (136) CdtProblem
    (137) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (138) CdtProblem
    (139) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 14 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) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 6 ms]
    (148) CdtProblem
    (149) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (150) CdtProblem
    (151) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (152) CdtProblem
    (153) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (154) CdtProblem
    (155) CdtLeafRemovalProof [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) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (164) CdtProblem


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

(0)
Obligation:
The Derivational Complexity (innermost) of the given DCpxTrs could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   app(app(app(fold, f), x), nil) -> x
   app(app(app(fold, f), x), app(app(cons, y), z)) -> app(app(f, y), app(app(app(fold, f), x), z))
   app(app(plus, 0), y) -> y
   app(app(plus, app(s, x)), y) -> app(s, app(app(plus, x), y))
   app(app(times, 0), y) -> 0
   app(app(times, app(s, x)), y) -> app(app(plus, app(app(times, x), y)), y)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))

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

(1) DerivationalComplexityToRuntimeComplexityProof (BOTH BOUNDS(ID, ID))
The following rules have been added to S to convert the given derivational complexity problem to a runtime complexity problem:

   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(x_1, x_2)) -> app(encArg(x_1), encArg(x_2))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   encode_app(x_1, x_2) -> app(encArg(x_1), encArg(x_2))
   encode_fold -> fold
   encode_nil -> nil
   encode_cons -> cons
   encode_plus -> plus
   encode_0 -> 0
   encode_s -> s
   encode_times -> times
   encode_sum -> sum
   encode_add -> add
   encode_prod -> prod
   encode_mul -> mul


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

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


The TRS R consists of the following rules:

   app(app(app(fold, f), x), nil) -> x
   app(app(app(fold, f), x), app(app(cons, y), z)) -> app(app(f, y), app(app(app(fold, f), x), z))
   app(app(plus, 0), y) -> y
   app(app(plus, app(s, x)), y) -> app(s, app(app(plus, x), y))
   app(app(times, 0), y) -> 0
   app(app(times, app(s, x)), y) -> app(app(plus, app(app(times, x), y)), y)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))

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

   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(x_1, x_2)) -> app(encArg(x_1), encArg(x_2))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   encode_app(x_1, x_2) -> app(encArg(x_1), encArg(x_2))
   encode_fold -> fold
   encode_nil -> nil
   encode_cons -> cons
   encode_plus -> plus
   encode_0 -> 0
   encode_s -> s
   encode_times -> times
   encode_sum -> sum
   encode_add -> add
   encode_prod -> prod
   encode_mul -> mul

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

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

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


The TRS R consists of the following rules:

   app(app(app(fold, f), x), nil) -> x
   app(app(app(fold, f), x), app(app(cons, y), z)) -> app(app(f, y), app(app(app(fold, f), x), z))
   app(app(plus, 0), y) -> y
   app(app(plus, app(s, x)), y) -> app(s, app(app(plus, x), y))
   app(app(times, 0), y) -> 0
   app(app(times, app(s, x)), y) -> app(app(plus, app(app(times, x), y)), y)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))

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

   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(x_1, x_2)) -> app(encArg(x_1), encArg(x_2))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   encode_app(x_1, x_2) -> app(encArg(x_1), encArg(x_2))
   encode_fold -> fold
   encode_nil -> nil
   encode_cons -> cons
   encode_plus -> plus
   encode_0 -> 0
   encode_s -> s
   encode_times -> times
   encode_sum -> sum
   encode_add -> add
   encode_prod -> prod
   encode_mul -> mul

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

(5) RelTrsToDecreasingLoopProblemProof (LOWER BOUND(ID))
Transformed a relative TRS into a decreasing-loop problem.
----------------------------------------

(6)
Obligation:
Analyzing the following TRS for decreasing loops:

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


The TRS R consists of the following rules:

   app(app(app(fold, f), x), nil) -> x
   app(app(app(fold, f), x), app(app(cons, y), z)) -> app(app(f, y), app(app(app(fold, f), x), z))
   app(app(plus, 0), y) -> y
   app(app(plus, app(s, x)), y) -> app(s, app(app(plus, x), y))
   app(app(times, 0), y) -> 0
   app(app(times, app(s, x)), y) -> app(app(plus, app(app(times, x), y)), y)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))

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

   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(x_1, x_2)) -> app(encArg(x_1), encArg(x_2))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   encode_app(x_1, x_2) -> app(encArg(x_1), encArg(x_2))
   encode_fold -> fold
   encode_nil -> nil
   encode_cons -> cons
   encode_plus -> plus
   encode_0 -> 0
   encode_s -> s
   encode_times -> times
   encode_sum -> sum
   encode_add -> add
   encode_prod -> prod
   encode_mul -> mul

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

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

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


The TRS R consists of the following rules:

   app(app(app(fold, f), x), nil) -> x
   app(app(app(fold, f), x), app(app(cons, y), z)) -> app(app(f, y), app(app(app(fold, f), x), z))
   app(app(plus, 0'), y) -> y
   app(app(plus, app(s, x)), y) -> app(s, app(app(plus, x), y))
   app(app(times, 0'), y) -> 0'
   app(app(times, app(s, x)), y) -> app(app(plus, app(app(times, x), y)), y)
   sum -> app(app(fold, add), 0')
   prod -> app(app(fold, mul), app(s, 0'))

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

   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0') -> 0'
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(x_1, x_2)) -> app(encArg(x_1), encArg(x_2))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   encode_app(x_1, x_2) -> app(encArg(x_1), encArg(x_2))
   encode_fold -> fold
   encode_nil -> nil
   encode_cons -> cons
   encode_plus -> plus
   encode_0 -> 0'
   encode_s -> s
   encode_times -> times
   encode_sum -> sum
   encode_add -> add
   encode_prod -> prod
   encode_mul -> mul

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

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

(10)
Obligation:
Innermost TRS:
Rules:
app(app(app(fold, f), x), nil) -> x
app(app(app(fold, f), x), app(app(cons, y), z)) -> app(app(f, y), app(app(app(fold, f), x), z))
app(app(plus, 0'), y) -> y
app(app(plus, app(s, x)), y) -> app(s, app(app(plus, x), y))
app(app(times, 0'), y) -> 0'
app(app(times, app(s, x)), y) -> app(app(plus, app(app(times, x), y)), y)
sum -> app(app(fold, add), 0')
prod -> app(app(fold, mul), app(s, 0'))
encArg(fold) -> fold
encArg(nil) -> nil
encArg(cons) -> cons
encArg(plus) -> plus
encArg(0') -> 0'
encArg(s) -> s
encArg(times) -> times
encArg(add) -> add
encArg(mul) -> mul
encArg(cons_app(x_1, x_2)) -> app(encArg(x_1), encArg(x_2))
encArg(cons_sum) -> sum
encArg(cons_prod) -> prod
encode_app(x_1, x_2) -> app(encArg(x_1), encArg(x_2))
encode_fold -> fold
encode_nil -> nil
encode_cons -> cons
encode_plus -> plus
encode_0 -> 0'
encode_s -> s
encode_times -> times
encode_sum -> sum
encode_add -> add
encode_prod -> prod
encode_mul -> mul

Types:
app :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod -> fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod -> fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
fold :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
nil :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
cons :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
plus :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
0' :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
s :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
times :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
sum :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
add :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
prod :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
mul :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
encArg :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod -> fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
cons_app :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod -> fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod -> fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
cons_sum :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
cons_prod :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
encode_app :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod -> fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod -> fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
encode_fold :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
encode_nil :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
encode_cons :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
encode_plus :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
encode_0 :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
encode_s :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
encode_times :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
encode_sum :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
encode_add :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
encode_prod :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
encode_mul :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
hole_fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod1_3 :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
gen_fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod2_3 :: Nat -> fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod

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

(11) OrderProof (LOWER BOUND(ID))
Heuristically decided to analyse the following defined symbols:
app, encArg

They will be analysed ascendingly in the following order:
app < encArg

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

(12)
Obligation:
Innermost TRS:
Rules:
app(app(app(fold, f), x), nil) -> x
app(app(app(fold, f), x), app(app(cons, y), z)) -> app(app(f, y), app(app(app(fold, f), x), z))
app(app(plus, 0'), y) -> y
app(app(plus, app(s, x)), y) -> app(s, app(app(plus, x), y))
app(app(times, 0'), y) -> 0'
app(app(times, app(s, x)), y) -> app(app(plus, app(app(times, x), y)), y)
sum -> app(app(fold, add), 0')
prod -> app(app(fold, mul), app(s, 0'))
encArg(fold) -> fold
encArg(nil) -> nil
encArg(cons) -> cons
encArg(plus) -> plus
encArg(0') -> 0'
encArg(s) -> s
encArg(times) -> times
encArg(add) -> add
encArg(mul) -> mul
encArg(cons_app(x_1, x_2)) -> app(encArg(x_1), encArg(x_2))
encArg(cons_sum) -> sum
encArg(cons_prod) -> prod
encode_app(x_1, x_2) -> app(encArg(x_1), encArg(x_2))
encode_fold -> fold
encode_nil -> nil
encode_cons -> cons
encode_plus -> plus
encode_0 -> 0'
encode_s -> s
encode_times -> times
encode_sum -> sum
encode_add -> add
encode_prod -> prod
encode_mul -> mul

Types:
app :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod -> fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod -> fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
fold :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
nil :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
cons :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
plus :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
0' :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
s :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
times :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
sum :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
add :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
prod :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
mul :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
encArg :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod -> fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
cons_app :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod -> fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod -> fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
cons_sum :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
cons_prod :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
encode_app :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod -> fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod -> fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
encode_fold :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
encode_nil :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
encode_cons :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
encode_plus :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
encode_0 :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
encode_s :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
encode_times :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
encode_sum :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
encode_add :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
encode_prod :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
encode_mul :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
hole_fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod1_3 :: fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod
gen_fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod2_3 :: Nat -> fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod


Generator Equations:
gen_fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod2_3(0) <=> fold
gen_fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod2_3(+(x, 1)) <=> cons_app(fold, gen_fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod2_3(x))


The following defined symbols remain to be analysed:
app, encArg

They will be analysed ascendingly in the following order:
app < encArg

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

(13) RewriteLemmaProof (LOWER BOUND(ID))
Proved the following rewrite lemma:
encArg(gen_fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod2_3(n248_3)) -> *3_3, rt in Omega(0)

Induction Base:
encArg(gen_fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod2_3(0))

Induction Step:
encArg(gen_fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod2_3(+(n248_3, 1))) ->_R^Omega(0)
app(encArg(fold), encArg(gen_fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod2_3(n248_3))) ->_R^Omega(0)
app(fold, encArg(gen_fold:nil:cons:plus:0':s:times:add:mul:cons_app:cons_sum:cons_prod2_3(n248_3))) ->_IH
app(fold, *3_3)

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

(14)
BOUNDS(1, INF)

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

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

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


The TRS R consists of the following rules:

   app(app(app(fold, f), x), nil) -> x
   app(app(app(fold, f), x), app(app(cons, y), z)) -> app(app(f, y), app(app(app(fold, f), x), z))
   app(app(plus, 0), y) -> y
   app(app(plus, app(s, x)), y) -> app(s, app(app(plus, x), y))
   app(app(times, 0), y) -> 0
   app(app(times, app(s, x)), y) -> app(app(plus, app(app(times, x), y)), y)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(x_1, x_2)) -> app(encArg(x_1), encArg(x_2))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   encode_app(x_1, x_2) -> app(encArg(x_1), encArg(x_2))
   encode_fold -> fold
   encode_nil -> nil
   encode_cons -> cons
   encode_plus -> plus
   encode_0 -> 0
   encode_s -> s
   encode_times -> times
   encode_sum -> sum
   encode_add -> add
   encode_prod -> prod
   encode_mul -> mul

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

(17) NonCtorToCtorProof (UPPER BOUND(ID))
transformed non-ctor to ctor-system
----------------------------------------

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


The TRS R consists of the following rules:

   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
   app(c_app(plus, c_app(s, x)), y) -> app(s, app(app(plus, x), y))
   app(c_app(times, 0), y) -> 0
   app(c_app(times, c_app(s, x)), y) -> app(app(plus, app(app(times, x), y)), y)
   app(c_app(c_app(fold, f), x), nil) -> x
   app(c_app(c_app(fold, f), x), c_app(c_app(cons, y), z)) -> app(app(f, y), app(app(app(fold, f), x), z))
   app(c_app(plus, 0), y) -> y

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

   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(x_1, x_2)) -> app(encArg(x_1), encArg(x_2))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   encode_app(x_1, x_2) -> app(encArg(x_1), encArg(x_2))
   encode_fold -> fold
   encode_nil -> nil
   encode_cons -> cons
   encode_plus -> plus
   encode_0 -> 0
   encode_s -> s
   encode_times -> times
   encode_sum -> sum
   encode_add -> add
   encode_prod -> prod
   encode_mul -> mul
   app(x0, x1) -> c_app(x0, x1)

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

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

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

   sum -> app(app(fold, add), 0) [1]
   prod -> app(app(fold, mul), app(s, 0)) [1]
   app(c_app(plus, c_app(s, x)), y) -> app(s, app(app(plus, x), y)) [1]
   app(c_app(times, 0), y) -> 0 [1]
   app(c_app(times, c_app(s, x)), y) -> app(app(plus, app(app(times, x), y)), y) [1]
   app(c_app(c_app(fold, f), x), nil) -> x [1]
   app(c_app(c_app(fold, f), x), c_app(c_app(cons, y), z)) -> app(app(f, y), app(app(app(fold, f), x), z)) [1]
   app(c_app(plus, 0), y) -> y [1]
   encArg(fold) -> fold [0]
   encArg(nil) -> nil [0]
   encArg(cons) -> cons [0]
   encArg(plus) -> plus [0]
   encArg(0) -> 0 [0]
   encArg(s) -> s [0]
   encArg(times) -> times [0]
   encArg(add) -> add [0]
   encArg(mul) -> mul [0]
   encArg(cons_app(x_1, x_2)) -> app(encArg(x_1), encArg(x_2)) [0]
   encArg(cons_sum) -> sum [0]
   encArg(cons_prod) -> prod [0]
   encode_app(x_1, x_2) -> app(encArg(x_1), encArg(x_2)) [0]
   encode_fold -> fold [0]
   encode_nil -> nil [0]
   encode_cons -> cons [0]
   encode_plus -> plus [0]
   encode_0 -> 0 [0]
   encode_s -> s [0]
   encode_times -> times [0]
   encode_sum -> sum [0]
   encode_add -> add [0]
   encode_prod -> prod [0]
   encode_mul -> mul [0]
   app(x0, x1) -> c_app(x0, x1) [0]

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

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

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

   sum -> app(app(fold, add), 0) [1]
   prod -> app(app(fold, mul), app(s, 0)) [1]
   app(c_app(plus, c_app(s, x)), y) -> app(s, app(app(plus, x), y)) [1]
   app(c_app(times, 0), y) -> 0 [1]
   app(c_app(times, c_app(s, x)), y) -> app(app(plus, app(app(times, x), y)), y) [1]
   app(c_app(c_app(fold, f), x), nil) -> x [1]
   app(c_app(c_app(fold, f), x), c_app(c_app(cons, y), z)) -> app(app(f, y), app(app(app(fold, f), x), z)) [1]
   app(c_app(plus, 0), y) -> y [1]
   encArg(fold) -> fold [0]
   encArg(nil) -> nil [0]
   encArg(cons) -> cons [0]
   encArg(plus) -> plus [0]
   encArg(0) -> 0 [0]
   encArg(s) -> s [0]
   encArg(times) -> times [0]
   encArg(add) -> add [0]
   encArg(mul) -> mul [0]
   encArg(cons_app(x_1, x_2)) -> app(encArg(x_1), encArg(x_2)) [0]
   encArg(cons_sum) -> sum [0]
   encArg(cons_prod) -> prod [0]
   encode_app(x_1, x_2) -> app(encArg(x_1), encArg(x_2)) [0]
   encode_fold -> fold [0]
   encode_nil -> nil [0]
   encode_cons -> cons [0]
   encode_plus -> plus [0]
   encode_0 -> 0 [0]
   encode_s -> s [0]
   encode_times -> times [0]
   encode_sum -> sum [0]
   encode_add -> add [0]
   encode_prod -> prod [0]
   encode_mul -> mul [0]
   app(x0, x1) -> c_app(x0, x1) [0]

The TRS has the following type information:
sum :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod
app :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod
fold :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod
add :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod
0 :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod
prod :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod
mul :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod
s :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod
c_app :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod
plus :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod
times :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod
nil :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod
cons :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod
encArg :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod
cons_app :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod
cons_sum :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod
cons_prod :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod
encode_app :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod
encode_fold :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod
encode_nil :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod
encode_cons :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod
encode_plus :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod
encode_0 :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod
encode_s :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod
encode_times :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod
encode_sum :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod
encode_add :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod
encode_prod :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod
encode_mul :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod

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

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

   encArg(v0) -> null_encArg [0]
   encode_app(v0, v1) -> null_encode_app [0]
   encode_fold -> null_encode_fold [0]
   encode_nil -> null_encode_nil [0]
   encode_cons -> null_encode_cons [0]
   encode_plus -> null_encode_plus [0]
   encode_0 -> null_encode_0 [0]
   encode_s -> null_encode_s [0]
   encode_times -> null_encode_times [0]
   encode_sum -> null_encode_sum [0]
   encode_add -> null_encode_add [0]
   encode_prod -> null_encode_prod [0]
   encode_mul -> null_encode_mul [0]
   app(v0, v1) -> null_app [0]

And the following fresh constants:    null_encArg, null_encode_app, null_encode_fold, null_encode_nil, null_encode_cons, null_encode_plus, null_encode_0, null_encode_s, null_encode_times, null_encode_sum, null_encode_add, null_encode_prod, null_encode_mul, null_app

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

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

   sum -> app(app(fold, add), 0) [1]
   prod -> app(app(fold, mul), app(s, 0)) [1]
   app(c_app(plus, c_app(s, x)), y) -> app(s, app(app(plus, x), y)) [1]
   app(c_app(times, 0), y) -> 0 [1]
   app(c_app(times, c_app(s, x)), y) -> app(app(plus, app(app(times, x), y)), y) [1]
   app(c_app(c_app(fold, f), x), nil) -> x [1]
   app(c_app(c_app(fold, f), x), c_app(c_app(cons, y), z)) -> app(app(f, y), app(app(app(fold, f), x), z)) [1]
   app(c_app(plus, 0), y) -> y [1]
   encArg(fold) -> fold [0]
   encArg(nil) -> nil [0]
   encArg(cons) -> cons [0]
   encArg(plus) -> plus [0]
   encArg(0) -> 0 [0]
   encArg(s) -> s [0]
   encArg(times) -> times [0]
   encArg(add) -> add [0]
   encArg(mul) -> mul [0]
   encArg(cons_app(x_1, x_2)) -> app(encArg(x_1), encArg(x_2)) [0]
   encArg(cons_sum) -> sum [0]
   encArg(cons_prod) -> prod [0]
   encode_app(x_1, x_2) -> app(encArg(x_1), encArg(x_2)) [0]
   encode_fold -> fold [0]
   encode_nil -> nil [0]
   encode_cons -> cons [0]
   encode_plus -> plus [0]
   encode_0 -> 0 [0]
   encode_s -> s [0]
   encode_times -> times [0]
   encode_sum -> sum [0]
   encode_add -> add [0]
   encode_prod -> prod [0]
   encode_mul -> mul [0]
   app(x0, x1) -> c_app(x0, x1) [0]
   encArg(v0) -> null_encArg [0]
   encode_app(v0, v1) -> null_encode_app [0]
   encode_fold -> null_encode_fold [0]
   encode_nil -> null_encode_nil [0]
   encode_cons -> null_encode_cons [0]
   encode_plus -> null_encode_plus [0]
   encode_0 -> null_encode_0 [0]
   encode_s -> null_encode_s [0]
   encode_times -> null_encode_times [0]
   encode_sum -> null_encode_sum [0]
   encode_add -> null_encode_add [0]
   encode_prod -> null_encode_prod [0]
   encode_mul -> null_encode_mul [0]
   app(v0, v1) -> null_app [0]

The TRS has the following type information:
sum :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
app :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
fold :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
add :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
0 :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
prod :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
mul :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
s :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
c_app :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
plus :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
times :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
nil :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
cons :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encArg :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
cons_app :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
cons_sum :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
cons_prod :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_app :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_fold :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_nil :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_cons :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_plus :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_0 :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_s :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_times :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_sum :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_add :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_prod :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_mul :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encArg :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_app :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_fold :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_nil :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_cons :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_plus :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_0 :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_s :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_times :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_sum :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_add :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_prod :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_mul :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_app :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app

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

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

   fold => 5
   add => 1
   0 => 0
   mul => 6
   s => 9
   plus => 8
   times => 10
   nil => 7
   cons => 2
   cons_sum => 4
   cons_prod => 3
   null_encArg => 0
   null_encode_app => 0
   null_encode_fold => 0
   null_encode_nil => 0
   null_encode_cons => 0
   null_encode_plus => 0
   null_encode_0 => 0
   null_encode_s => 0
   null_encode_times => 0
   null_encode_sum => 0
   null_encode_add => 0
   null_encode_prod => 0
   null_encode_mul => 0
   null_app => 0

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

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

   app(z', z'') -{ 1 }-> x :|: f >= 0, z'' = 7, z' = 1 + (1 + 5 + f) + x, x >= 0
   app(z', z'') -{ 1 }-> y :|: z' = 1 + 8 + 0, z'' = y, y >= 0
   app(z', z'') -{ 1 }-> app(app(f, y), app(app(app(5, f), x), z)) :|: f >= 0, z >= 0, z' = 1 + (1 + 5 + f) + x, x >= 0, y >= 0, z'' = 1 + (1 + 2 + y) + z
   app(z', z'') -{ 1 }-> app(app(8, app(app(10, x), y)), y) :|: z'' = y, x >= 0, y >= 0, z' = 1 + 10 + (1 + 9 + x)
   app(z', z'') -{ 1 }-> app(9, app(app(8, x), y)) :|: z'' = y, x >= 0, y >= 0, z' = 1 + 8 + (1 + 9 + x)
   app(z', z'') -{ 1 }-> 0 :|: z' = 1 + 10 + 0, z'' = y, y >= 0
   app(z', z'') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z'' = v1, z' = v0
   app(z', z'') -{ 0 }-> 1 + x0 + x1 :|: z'' = x1, x0 >= 0, x1 >= 0, z' = x0
   encArg(z') -{ 0 }-> sum :|: z' = 4
   encArg(z') -{ 0 }-> prod :|: z' = 3
   encArg(z') -{ 0 }-> app(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, x_2 >= 0, z' = 1 + x_1 + x_2
   encArg(z') -{ 0 }-> 9 :|: z' = 9
   encArg(z') -{ 0 }-> 8 :|: z' = 8
   encArg(z') -{ 0 }-> 7 :|: z' = 7
   encArg(z') -{ 0 }-> 6 :|: z' = 6
   encArg(z') -{ 0 }-> 5 :|: z' = 5
   encArg(z') -{ 0 }-> 2 :|: z' = 2
   encArg(z') -{ 0 }-> 10 :|: z' = 10
   encArg(z') -{ 0 }-> 1 :|: z' = 1
   encArg(z') -{ 0 }-> 0 :|: z' = 0
   encArg(z') -{ 0 }-> 0 :|: v0 >= 0, z' = v0
   encode_0 -{ 0 }-> 0 :|: 
   encode_add -{ 0 }-> 1 :|: 
   encode_add -{ 0 }-> 0 :|: 
   encode_app(z', z'') -{ 0 }-> app(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z' = x_1, x_2 >= 0, z'' = x_2
   encode_app(z', z'') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z'' = v1, z' = v0
   encode_cons -{ 0 }-> 2 :|: 
   encode_cons -{ 0 }-> 0 :|: 
   encode_fold -{ 0 }-> 5 :|: 
   encode_fold -{ 0 }-> 0 :|: 
   encode_mul -{ 0 }-> 6 :|: 
   encode_mul -{ 0 }-> 0 :|: 
   encode_nil -{ 0 }-> 7 :|: 
   encode_nil -{ 0 }-> 0 :|: 
   encode_plus -{ 0 }-> 8 :|: 
   encode_plus -{ 0 }-> 0 :|: 
   encode_prod -{ 0 }-> prod :|: 
   encode_prod -{ 0 }-> 0 :|: 
   encode_s -{ 0 }-> 9 :|: 
   encode_s -{ 0 }-> 0 :|: 
   encode_sum -{ 0 }-> sum :|: 
   encode_sum -{ 0 }-> 0 :|: 
   encode_times -{ 0 }-> 10 :|: 
   encode_times -{ 0 }-> 0 :|: 
   prod -{ 1 }-> app(app(5, 6), app(9, 0)) :|: 
   sum -{ 1 }-> app(app(5, 1), 0) :|: 

Only complete derivations are relevant for the runtime complexity.

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

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

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

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

(c) The following functions are completely defined:

   sum
   prod
   encArg_1
   encode_app_2
   encode_fold
   encode_nil
   encode_cons
   encode_plus
   encode_0
   encode_s
   encode_times
   encode_sum
   encode_add
   encode_prod
   encode_mul
   app_2

Due to the following rules being added:

   encArg(v0) -> null_encArg [0]
   encode_app(v0, v1) -> null_encode_app [0]
   encode_fold -> null_encode_fold [0]
   encode_nil -> null_encode_nil [0]
   encode_cons -> null_encode_cons [0]
   encode_plus -> null_encode_plus [0]
   encode_0 -> null_encode_0 [0]
   encode_s -> null_encode_s [0]
   encode_times -> null_encode_times [0]
   encode_sum -> null_encode_sum [0]
   encode_add -> null_encode_add [0]
   encode_prod -> null_encode_prod [0]
   encode_mul -> null_encode_mul [0]
   app(v0, v1) -> null_app [0]

And the following fresh constants:    null_encArg, null_encode_app, null_encode_fold, null_encode_nil, null_encode_cons, null_encode_plus, null_encode_0, null_encode_s, null_encode_times, null_encode_sum, null_encode_add, null_encode_prod, null_encode_mul, null_app

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

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

   sum -> app(app(fold, add), 0) [1]
   prod -> app(app(fold, mul), app(s, 0)) [1]
   app(c_app(plus, c_app(s, x)), y) -> app(s, app(app(plus, x), y)) [1]
   app(c_app(times, 0), y) -> 0 [1]
   app(c_app(times, c_app(s, x)), y) -> app(app(plus, app(app(times, x), y)), y) [1]
   app(c_app(c_app(fold, f), x), nil) -> x [1]
   app(c_app(c_app(fold, f), x), c_app(c_app(cons, y), z)) -> app(app(f, y), app(app(app(fold, f), x), z)) [1]
   app(c_app(plus, 0), y) -> y [1]
   encArg(fold) -> fold [0]
   encArg(nil) -> nil [0]
   encArg(cons) -> cons [0]
   encArg(plus) -> plus [0]
   encArg(0) -> 0 [0]
   encArg(s) -> s [0]
   encArg(times) -> times [0]
   encArg(add) -> add [0]
   encArg(mul) -> mul [0]
   encArg(cons_app(x_1, x_2)) -> app(encArg(x_1), encArg(x_2)) [0]
   encArg(cons_sum) -> sum [0]
   encArg(cons_prod) -> prod [0]
   encode_app(x_1, x_2) -> app(encArg(x_1), encArg(x_2)) [0]
   encode_fold -> fold [0]
   encode_nil -> nil [0]
   encode_cons -> cons [0]
   encode_plus -> plus [0]
   encode_0 -> 0 [0]
   encode_s -> s [0]
   encode_times -> times [0]
   encode_sum -> sum [0]
   encode_add -> add [0]
   encode_prod -> prod [0]
   encode_mul -> mul [0]
   app(x0, x1) -> c_app(x0, x1) [0]
   encArg(v0) -> null_encArg [0]
   encode_app(v0, v1) -> null_encode_app [0]
   encode_fold -> null_encode_fold [0]
   encode_nil -> null_encode_nil [0]
   encode_cons -> null_encode_cons [0]
   encode_plus -> null_encode_plus [0]
   encode_0 -> null_encode_0 [0]
   encode_s -> null_encode_s [0]
   encode_times -> null_encode_times [0]
   encode_sum -> null_encode_sum [0]
   encode_add -> null_encode_add [0]
   encode_prod -> null_encode_prod [0]
   encode_mul -> null_encode_mul [0]
   app(v0, v1) -> null_app [0]

The TRS has the following type information:
sum :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
app :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
fold :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
add :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
0 :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
prod :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
mul :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
s :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
c_app :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
plus :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
times :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
nil :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
cons :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encArg :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
cons_app :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
cons_sum :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
cons_prod :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_app :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_fold :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_nil :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_cons :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_plus :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_0 :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_s :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_times :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_sum :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_add :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_prod :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_mul :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encArg :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_app :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_fold :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_nil :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_cons :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_plus :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_0 :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_s :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_times :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_sum :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_add :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_prod :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_mul :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_app :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app

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

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

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

   sum -> app(c_app(fold, add), 0) [1]
   sum -> app(null_app, 0) [1]
   prod -> app(c_app(fold, mul), c_app(s, 0)) [1]
   prod -> app(c_app(fold, mul), null_app) [1]
   prod -> app(null_app, c_app(s, 0)) [1]
   prod -> app(null_app, null_app) [1]
   app(c_app(plus, c_app(s, x)), y) -> app(s, app(c_app(plus, x), y)) [1]
   app(c_app(plus, c_app(s, x)), y) -> app(s, app(null_app, y)) [1]
   app(c_app(times, 0), y) -> 0 [1]
   app(c_app(times, c_app(s, x)), y) -> app(app(plus, app(c_app(times, x), y)), y) [1]
   app(c_app(times, c_app(s, x)), y) -> app(app(plus, app(null_app, y)), y) [1]
   app(c_app(c_app(fold, f), x), nil) -> x [1]
   app(c_app(c_app(fold, c_app(plus, c_app(s, x'))), x), c_app(c_app(cons, y), z)) -> app(app(s, app(app(plus, x'), y)), app(app(c_app(fold, c_app(plus, c_app(s, x'))), x), z)) [2]
   app(c_app(c_app(fold, c_app(plus, c_app(s, x'))), x), c_app(c_app(cons, y), z)) -> app(app(s, app(app(plus, x'), y)), app(app(null_app, x), z)) [2]
   app(c_app(c_app(fold, c_app(times, 0)), x), c_app(c_app(cons, y), z)) -> app(0, app(app(c_app(fold, c_app(times, 0)), x), z)) [2]
   app(c_app(c_app(fold, c_app(times, 0)), x), c_app(c_app(cons, y), z)) -> app(0, app(app(null_app, x), z)) [2]
   app(c_app(c_app(fold, c_app(times, c_app(s, x''))), x), c_app(c_app(cons, y), z)) -> app(app(app(plus, app(app(times, x''), y)), y), app(app(c_app(fold, c_app(times, c_app(s, x''))), x), z)) [2]
   app(c_app(c_app(fold, c_app(times, c_app(s, x''))), x), c_app(c_app(cons, y), z)) -> app(app(app(plus, app(app(times, x''), y)), y), app(app(null_app, x), z)) [2]
   app(c_app(c_app(fold, c_app(c_app(fold, f'), x2)), x), c_app(c_app(cons, nil), z)) -> app(x2, app(app(c_app(fold, c_app(c_app(fold, f'), x2)), x), z)) [2]
   app(c_app(c_app(fold, c_app(c_app(fold, f'), x2)), x), c_app(c_app(cons, nil), z)) -> app(x2, app(app(null_app, x), z)) [2]
   app(c_app(c_app(fold, c_app(c_app(fold, f''), x3)), x), c_app(c_app(cons, c_app(c_app(cons, y'), z')), z)) -> app(app(app(f'', y'), app(app(app(fold, f''), x3), z')), app(app(c_app(fold, c_app(c_app(fold, f''), x3)), x), z)) [2]
   app(c_app(c_app(fold, c_app(c_app(fold, f''), x3)), x), c_app(c_app(cons, c_app(c_app(cons, y'), z')), z)) -> app(app(app(f'', y'), app(app(app(fold, f''), x3), z')), app(app(null_app, x), z)) [2]
   app(c_app(c_app(fold, c_app(plus, 0)), x), c_app(c_app(cons, y), z)) -> app(y, app(app(c_app(fold, c_app(plus, 0)), x), z)) [2]
   app(c_app(c_app(fold, c_app(plus, 0)), x), c_app(c_app(cons, y), z)) -> app(y, app(app(null_app, x), z)) [2]
   app(c_app(c_app(fold, f), x), c_app(c_app(cons, y), z)) -> app(c_app(f, y), app(app(c_app(fold, f), x), z)) [1]
   app(c_app(c_app(fold, f), x), c_app(c_app(cons, y), z)) -> app(c_app(f, y), app(app(null_app, x), z)) [1]
   app(c_app(c_app(fold, f), x), c_app(c_app(cons, y), z)) -> app(null_app, app(app(c_app(fold, f), x), z)) [1]
   app(c_app(c_app(fold, f), x), c_app(c_app(cons, y), z)) -> app(null_app, app(app(null_app, x), z)) [1]
   app(c_app(plus, 0), y) -> y [1]
   encArg(fold) -> fold [0]
   encArg(nil) -> nil [0]
   encArg(cons) -> cons [0]
   encArg(plus) -> plus [0]
   encArg(0) -> 0 [0]
   encArg(s) -> s [0]
   encArg(times) -> times [0]
   encArg(add) -> add [0]
   encArg(mul) -> mul [0]
   encArg(cons_app(x_1, x_2)) -> app(encArg(x_1), encArg(x_2)) [0]
   encArg(cons_sum) -> sum [0]
   encArg(cons_prod) -> prod [0]
   encode_app(x_1, x_2) -> app(encArg(x_1), encArg(x_2)) [0]
   encode_fold -> fold [0]
   encode_nil -> nil [0]
   encode_cons -> cons [0]
   encode_plus -> plus [0]
   encode_0 -> 0 [0]
   encode_s -> s [0]
   encode_times -> times [0]
   encode_sum -> sum [0]
   encode_add -> add [0]
   encode_prod -> prod [0]
   encode_mul -> mul [0]
   app(x0, x1) -> c_app(x0, x1) [0]
   encArg(v0) -> null_encArg [0]
   encode_app(v0, v1) -> null_encode_app [0]
   encode_fold -> null_encode_fold [0]
   encode_nil -> null_encode_nil [0]
   encode_cons -> null_encode_cons [0]
   encode_plus -> null_encode_plus [0]
   encode_0 -> null_encode_0 [0]
   encode_s -> null_encode_s [0]
   encode_times -> null_encode_times [0]
   encode_sum -> null_encode_sum [0]
   encode_add -> null_encode_add [0]
   encode_prod -> null_encode_prod [0]
   encode_mul -> null_encode_mul [0]
   app(v0, v1) -> null_app [0]

The TRS has the following type information:
sum :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
app :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
fold :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
add :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
0 :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
prod :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
mul :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
s :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
c_app :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
plus :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
times :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
nil :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
cons :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encArg :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
cons_app :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
cons_sum :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
cons_prod :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_app :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app -> fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_fold :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_nil :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_cons :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_plus :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_0 :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_s :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_times :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_sum :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_add :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_prod :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
encode_mul :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encArg :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_app :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_fold :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_nil :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_cons :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_plus :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_0 :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_s :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_times :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_sum :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_add :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_prod :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_encode_mul :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app
null_app :: fold:add:0:mul:s:plus:c_app:times:nil:cons:cons_app:cons_sum:cons_prod:null_encArg:null_encode_app:null_encode_fold:null_encode_nil:null_encode_cons:null_encode_plus:null_encode_0:null_encode_s:null_encode_times:null_encode_sum:null_encode_add:null_encode_prod:null_encode_mul:null_app

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

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

   fold => 5
   add => 1
   0 => 0
   mul => 6
   s => 9
   plus => 8
   times => 10
   nil => 7
   cons => 2
   cons_sum => 4
   cons_prod => 3
   null_encArg => 0
   null_encode_app => 0
   null_encode_fold => 0
   null_encode_nil => 0
   null_encode_cons => 0
   null_encode_plus => 0
   null_encode_0 => 0
   null_encode_s => 0
   null_encode_times => 0
   null_encode_sum => 0
   null_encode_add => 0
   null_encode_prod => 0
   null_encode_mul => 0
   null_app => 0

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

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

   app(z'', z1) -{ 1 }-> x :|: f >= 0, z1 = 7, z'' = 1 + (1 + 5 + f) + x, x >= 0
   app(z'', z1) -{ 1 }-> y :|: z1 = y, y >= 0, z'' = 1 + 8 + 0
   app(z'', z1) -{ 2 }-> app(x2, app(app(0, x), z)) :|: z >= 0, f' >= 0, z'' = 1 + (1 + 5 + (1 + (1 + 5 + f') + x2)) + x, x >= 0, z1 = 1 + (1 + 2 + 7) + z, x2 >= 0
   app(z'', z1) -{ 2 }-> app(x2, app(app(1 + 5 + (1 + (1 + 5 + f') + x2), x), z)) :|: z >= 0, f' >= 0, z'' = 1 + (1 + 5 + (1 + (1 + 5 + f') + x2)) + x, x >= 0, z1 = 1 + (1 + 2 + 7) + z, x2 >= 0
   app(z'', z1) -{ 2 }-> app(y, app(app(0, x), z)) :|: z >= 0, x >= 0, y >= 0, z'' = 1 + (1 + 5 + (1 + 8 + 0)) + x, z1 = 1 + (1 + 2 + y) + z
   app(z'', z1) -{ 2 }-> app(y, app(app(1 + 5 + (1 + 8 + 0), x), z)) :|: z >= 0, x >= 0, y >= 0, z'' = 1 + (1 + 5 + (1 + 8 + 0)) + x, z1 = 1 + (1 + 2 + y) + z
   app(z'', z1) -{ 2 }-> app(app(app(f'', y'), app(app(app(5, f''), x3), z')), app(app(0, x), z)) :|: z >= 0, f'' >= 0, x >= 0, z' >= 0, z'' = 1 + (1 + 5 + (1 + (1 + 5 + f'') + x3)) + x, y' >= 0, z1 = 1 + (1 + 2 + (1 + (1 + 2 + y') + z')) + z, x3 >= 0
   app(z'', z1) -{ 2 }-> app(app(app(f'', y'), app(app(app(5, f''), x3), z')), app(app(1 + 5 + (1 + (1 + 5 + f'') + x3), x), z)) :|: z >= 0, f'' >= 0, x >= 0, z' >= 0, z'' = 1 + (1 + 5 + (1 + (1 + 5 + f'') + x3)) + x, y' >= 0, z1 = 1 + (1 + 2 + (1 + (1 + 2 + y') + z')) + z, x3 >= 0
   app(z'', z1) -{ 2 }-> app(app(app(8, app(app(10, x''), y)), y), app(app(0, x), z)) :|: z >= 0, x >= 0, y >= 0, z1 = 1 + (1 + 2 + y) + z, x'' >= 0, z'' = 1 + (1 + 5 + (1 + 10 + (1 + 9 + x''))) + x
   app(z'', z1) -{ 2 }-> app(app(app(8, app(app(10, x''), y)), y), app(app(1 + 5 + (1 + 10 + (1 + 9 + x'')), x), z)) :|: z >= 0, x >= 0, y >= 0, z1 = 1 + (1 + 2 + y) + z, x'' >= 0, z'' = 1 + (1 + 5 + (1 + 10 + (1 + 9 + x''))) + x
   app(z'', z1) -{ 2 }-> app(app(9, app(app(8, x'), y)), app(app(0, x), z)) :|: z >= 0, x' >= 0, x >= 0, y >= 0, z1 = 1 + (1 + 2 + y) + z, z'' = 1 + (1 + 5 + (1 + 8 + (1 + 9 + x'))) + x
   app(z'', z1) -{ 2 }-> app(app(9, app(app(8, x'), y)), app(app(1 + 5 + (1 + 8 + (1 + 9 + x')), x), z)) :|: z >= 0, x' >= 0, x >= 0, y >= 0, z1 = 1 + (1 + 2 + y) + z, z'' = 1 + (1 + 5 + (1 + 8 + (1 + 9 + x'))) + x
   app(z'', z1) -{ 1 }-> app(app(8, app(0, y)), y) :|: z1 = y, x >= 0, y >= 0, z'' = 1 + 10 + (1 + 9 + x)
   app(z'', z1) -{ 1 }-> app(app(8, app(1 + 10 + x, y)), y) :|: z1 = y, x >= 0, y >= 0, z'' = 1 + 10 + (1 + 9 + x)
   app(z'', z1) -{ 1 }-> app(9, app(0, y)) :|: z'' = 1 + 8 + (1 + 9 + x), z1 = y, x >= 0, y >= 0
   app(z'', z1) -{ 1 }-> app(9, app(1 + 8 + x, y)) :|: z'' = 1 + 8 + (1 + 9 + x), z1 = y, x >= 0, y >= 0
   app(z'', z1) -{ 2 }-> app(0, app(app(0, x), z)) :|: z >= 0, x >= 0, y >= 0, z1 = 1 + (1 + 2 + y) + z, z'' = 1 + (1 + 5 + (1 + 10 + 0)) + x
   app(z'', z1) -{ 1 }-> app(0, app(app(0, x), z)) :|: f >= 0, z >= 0, z'' = 1 + (1 + 5 + f) + x, x >= 0, y >= 0, z1 = 1 + (1 + 2 + y) + z
   app(z'', z1) -{ 1 }-> app(0, app(app(1 + 5 + f, x), z)) :|: f >= 0, z >= 0, z'' = 1 + (1 + 5 + f) + x, x >= 0, y >= 0, z1 = 1 + (1 + 2 + y) + z
   app(z'', z1) -{ 2 }-> app(0, app(app(1 + 5 + (1 + 10 + 0), x), z)) :|: z >= 0, x >= 0, y >= 0, z1 = 1 + (1 + 2 + y) + z, z'' = 1 + (1 + 5 + (1 + 10 + 0)) + x
   app(z'', z1) -{ 1 }-> app(1 + f + y, app(app(0, x), z)) :|: f >= 0, z >= 0, z'' = 1 + (1 + 5 + f) + x, x >= 0, y >= 0, z1 = 1 + (1 + 2 + y) + z
   app(z'', z1) -{ 1 }-> app(1 + f + y, app(app(1 + 5 + f, x), z)) :|: f >= 0, z >= 0, z'' = 1 + (1 + 5 + f) + x, x >= 0, y >= 0, z1 = 1 + (1 + 2 + y) + z
   app(z'', z1) -{ 1 }-> 0 :|: z1 = y, z'' = 1 + 10 + 0, y >= 0
   app(z'', z1) -{ 0 }-> 0 :|: z'' = v0, v0 >= 0, z1 = v1, v1 >= 0
   app(z'', z1) -{ 0 }-> 1 + x0 + x1 :|: x0 >= 0, x1 >= 0, z1 = x1, z'' = x0
   encArg(z'') -{ 0 }-> sum :|: z'' = 4
   encArg(z'') -{ 0 }-> prod :|: z'' = 3
   encArg(z'') -{ 0 }-> app(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, x_2 >= 0, z'' = 1 + x_1 + x_2
   encArg(z'') -{ 0 }-> 9 :|: z'' = 9
   encArg(z'') -{ 0 }-> 8 :|: z'' = 8
   encArg(z'') -{ 0 }-> 7 :|: z'' = 7
   encArg(z'') -{ 0 }-> 6 :|: z'' = 6
   encArg(z'') -{ 0 }-> 5 :|: z'' = 5
   encArg(z'') -{ 0 }-> 2 :|: z'' = 2
   encArg(z'') -{ 0 }-> 10 :|: z'' = 10
   encArg(z'') -{ 0 }-> 1 :|: z'' = 1
   encArg(z'') -{ 0 }-> 0 :|: z'' = 0
   encArg(z'') -{ 0 }-> 0 :|: z'' = v0, v0 >= 0
   encode_0 -{ 0 }-> 0 :|: 
   encode_add -{ 0 }-> 1 :|: 
   encode_add -{ 0 }-> 0 :|: 
   encode_app(z'', z1) -{ 0 }-> app(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, z'' = x_1, z1 = x_2, x_2 >= 0
   encode_app(z'', z1) -{ 0 }-> 0 :|: z'' = v0, v0 >= 0, z1 = v1, v1 >= 0
   encode_cons -{ 0 }-> 2 :|: 
   encode_cons -{ 0 }-> 0 :|: 
   encode_fold -{ 0 }-> 5 :|: 
   encode_fold -{ 0 }-> 0 :|: 
   encode_mul -{ 0 }-> 6 :|: 
   encode_mul -{ 0 }-> 0 :|: 
   encode_nil -{ 0 }-> 7 :|: 
   encode_nil -{ 0 }-> 0 :|: 
   encode_plus -{ 0 }-> 8 :|: 
   encode_plus -{ 0 }-> 0 :|: 
   encode_prod -{ 0 }-> prod :|: 
   encode_prod -{ 0 }-> 0 :|: 
   encode_s -{ 0 }-> 9 :|: 
   encode_s -{ 0 }-> 0 :|: 
   encode_sum -{ 0 }-> sum :|: 
   encode_sum -{ 0 }-> 0 :|: 
   encode_times -{ 0 }-> 10 :|: 
   encode_times -{ 0 }-> 0 :|: 
   prod -{ 1 }-> app(0, 0) :|: 
   prod -{ 1 }-> app(0, 1 + 9 + 0) :|: 
   prod -{ 1 }-> app(1 + 5 + 6, 0) :|: 
   prod -{ 1 }-> app(1 + 5 + 6, 1 + 9 + 0) :|: 
   sum -{ 1 }-> app(0, 0) :|: 
   sum -{ 1 }-> app(1 + 5 + 1, 0) :|: 


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

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

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

   app(z'', z1) -{ 1 }-> x :|: f >= 0, z1 = 7, z'' = 1 + (1 + 5 + f) + x, x >= 0
   app(z'', z1) -{ 1 }-> z1 :|: z1 >= 0, z'' = 1 + 8 + 0
   app(z'', z1) -{ 2 }-> app(x2, app(app(0, x), z1 - 11)) :|: z1 - 11 >= 0, f' >= 0, z'' = 1 + (1 + 5 + (1 + (1 + 5 + f') + x2)) + x, x >= 0, x2 >= 0
   app(z'', z1) -{ 2 }-> app(x2, app(app(1 + 5 + (1 + (1 + 5 + f') + x2), x), z1 - 11)) :|: z1 - 11 >= 0, f' >= 0, z'' = 1 + (1 + 5 + (1 + (1 + 5 + f') + x2)) + x, x >= 0, x2 >= 0
   app(z'', z1) -{ 2 }-> app(y, app(app(0, z'' - 16), z)) :|: z >= 0, z'' - 16 >= 0, y >= 0, z1 = 1 + (1 + 2 + y) + z
   app(z'', z1) -{ 2 }-> app(y, app(app(1 + 5 + (1 + 8 + 0), z'' - 16), z)) :|: z >= 0, z'' - 16 >= 0, y >= 0, z1 = 1 + (1 + 2 + y) + z
   app(z'', z1) -{ 2 }-> app(app(app(f'', y'), app(app(app(5, f''), x3), z')), app(app(0, x), z)) :|: z >= 0, f'' >= 0, x >= 0, z' >= 0, z'' = 1 + (1 + 5 + (1 + (1 + 5 + f'') + x3)) + x, y' >= 0, z1 = 1 + (1 + 2 + (1 + (1 + 2 + y') + z')) + z, x3 >= 0
   app(z'', z1) -{ 2 }-> app(app(app(f'', y'), app(app(app(5, f''), x3), z')), app(app(1 + 5 + (1 + (1 + 5 + f'') + x3), x), z)) :|: z >= 0, f'' >= 0, x >= 0, z' >= 0, z'' = 1 + (1 + 5 + (1 + (1 + 5 + f'') + x3)) + x, y' >= 0, z1 = 1 + (1 + 2 + (1 + (1 + 2 + y') + z')) + z, x3 >= 0
   app(z'', z1) -{ 2 }-> app(app(app(8, app(app(10, x''), y)), y), app(app(0, x), z)) :|: z >= 0, x >= 0, y >= 0, z1 = 1 + (1 + 2 + y) + z, x'' >= 0, z'' = 1 + (1 + 5 + (1 + 10 + (1 + 9 + x''))) + x
   app(z'', z1) -{ 2 }-> app(app(app(8, app(app(10, x''), y)), y), app(app(1 + 5 + (1 + 10 + (1 + 9 + x'')), x), z)) :|: z >= 0, x >= 0, y >= 0, z1 = 1 + (1 + 2 + y) + z, x'' >= 0, z'' = 1 + (1 + 5 + (1 + 10 + (1 + 9 + x''))) + x
   app(z'', z1) -{ 2 }-> app(app(9, app(app(8, x'), y)), app(app(0, x), z)) :|: z >= 0, x' >= 0, x >= 0, y >= 0, z1 = 1 + (1 + 2 + y) + z, z'' = 1 + (1 + 5 + (1 + 8 + (1 + 9 + x'))) + x
   app(z'', z1) -{ 2 }-> app(app(9, app(app(8, x'), y)), app(app(1 + 5 + (1 + 8 + (1 + 9 + x')), x), z)) :|: z >= 0, x' >= 0, x >= 0, y >= 0, z1 = 1 + (1 + 2 + y) + z, z'' = 1 + (1 + 5 + (1 + 8 + (1 + 9 + x'))) + x
   app(z'', z1) -{ 1 }-> app(app(8, app(0, z1)), z1) :|: z'' - 21 >= 0, z1 >= 0
   app(z'', z1) -{ 1 }-> app(app(8, app(1 + 10 + (z'' - 21), z1)), z1) :|: z'' - 21 >= 0, z1 >= 0
   app(z'', z1) -{ 1 }-> app(9, app(0, z1)) :|: z'' - 19 >= 0, z1 >= 0
   app(z'', z1) -{ 1 }-> app(9, app(1 + 8 + (z'' - 19), z1)) :|: z'' - 19 >= 0, z1 >= 0
   app(z'', z1) -{ 1 }-> app(0, app(app(0, x), z)) :|: f >= 0, z >= 0, z'' = 1 + (1 + 5 + f) + x, x >= 0, y >= 0, z1 = 1 + (1 + 2 + y) + z
   app(z'', z1) -{ 2 }-> app(0, app(app(0, z'' - 18), z)) :|: z >= 0, z'' - 18 >= 0, y >= 0, z1 = 1 + (1 + 2 + y) + z
   app(z'', z1) -{ 1 }-> app(0, app(app(1 + 5 + f, x), z)) :|: f >= 0, z >= 0, z'' = 1 + (1 + 5 + f) + x, x >= 0, y >= 0, z1 = 1 + (1 + 2 + y) + z
   app(z'', z1) -{ 2 }-> app(0, app(app(1 + 5 + (1 + 10 + 0), z'' - 18), z)) :|: z >= 0, z'' - 18 >= 0, y >= 0, z1 = 1 + (1 + 2 + y) + z
   app(z'', z1) -{ 1 }-> app(1 + f + y, app(app(0, x), z)) :|: f >= 0, z >= 0, z'' = 1 + (1 + 5 + f) + x, x >= 0, y >= 0, z1 = 1 + (1 + 2 + y) + z
   app(z'', z1) -{ 1 }-> app(1 + f + y, app(app(1 + 5 + f, x), z)) :|: f >= 0, z >= 0, z'' = 1 + (1 + 5 + f) + x, x >= 0, y >= 0, z1 = 1 + (1 + 2 + y) + z
   app(z'', z1) -{ 1 }-> 0 :|: z'' = 1 + 10 + 0, z1 >= 0
   app(z'', z1) -{ 0 }-> 0 :|: z'' >= 0, z1 >= 0
   app(z'', z1) -{ 0 }-> 1 + z'' + z1 :|: z'' >= 0, z1 >= 0
   encArg(z'') -{ 0 }-> sum :|: z'' = 4
   encArg(z'') -{ 0 }-> prod :|: z'' = 3
   encArg(z'') -{ 0 }-> app(encArg(x_1), encArg(x_2)) :|: x_1 >= 0, x_2 >= 0, z'' = 1 + x_1 + x_2
   encArg(z'') -{ 0 }-> 9 :|: z'' = 9
   encArg(z'') -{ 0 }-> 8 :|: z'' = 8
   encArg(z'') -{ 0 }-> 7 :|: z'' = 7
   encArg(z'') -{ 0 }-> 6 :|: z'' = 6
   encArg(z'') -{ 0 }-> 5 :|: z'' = 5
   encArg(z'') -{ 0 }-> 2 :|: z'' = 2
   encArg(z'') -{ 0 }-> 10 :|: z'' = 10
   encArg(z'') -{ 0 }-> 1 :|: z'' = 1
   encArg(z'') -{ 0 }-> 0 :|: z'' = 0
   encArg(z'') -{ 0 }-> 0 :|: z'' >= 0
   encode_0 -{ 0 }-> 0 :|: 
   encode_add -{ 0 }-> 1 :|: 
   encode_add -{ 0 }-> 0 :|: 
   encode_app(z'', z1) -{ 0 }-> app(encArg(z''), encArg(z1)) :|: z'' >= 0, z1 >= 0
   encode_app(z'', z1) -{ 0 }-> 0 :|: z'' >= 0, z1 >= 0
   encode_cons -{ 0 }-> 2 :|: 
   encode_cons -{ 0 }-> 0 :|: 
   encode_fold -{ 0 }-> 5 :|: 
   encode_fold -{ 0 }-> 0 :|: 
   encode_mul -{ 0 }-> 6 :|: 
   encode_mul -{ 0 }-> 0 :|: 
   encode_nil -{ 0 }-> 7 :|: 
   encode_nil -{ 0 }-> 0 :|: 
   encode_plus -{ 0 }-> 8 :|: 
   encode_plus -{ 0 }-> 0 :|: 
   encode_prod -{ 0 }-> prod :|: 
   encode_prod -{ 0 }-> 0 :|: 
   encode_s -{ 0 }-> 9 :|: 
   encode_s -{ 0 }-> 0 :|: 
   encode_sum -{ 0 }-> sum :|: 
   encode_sum -{ 0 }-> 0 :|: 
   encode_times -{ 0 }-> 10 :|: 
   encode_times -{ 0 }-> 0 :|: 
   prod -{ 1 }-> app(0, 0) :|: 
   prod -{ 1 }-> app(0, 1 + 9 + 0) :|: 
   prod -{ 1 }-> app(1 + 5 + 6, 0) :|: 
   prod -{ 1 }-> app(1 + 5 + 6, 1 + 9 + 0) :|: 
   sum -{ 1 }-> app(0, 0) :|: 
   sum -{ 1 }-> app(1 + 5 + 1, 0) :|: 


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

(35) CpxTrsToCdtProof (UPPER BOUND(ID))
Converted Cpx (relative) TRS to CDT
----------------------------------------

(36)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   encode_app(z0, z1) -> app(encArg(z0), encArg(z1))
   encode_fold -> fold
   encode_nil -> nil
   encode_cons -> cons
   encode_plus -> plus
   encode_0 -> 0
   encode_s -> s
   encode_times -> times
   encode_sum -> sum
   encode_add -> add
   encode_prod -> prod
   encode_mul -> mul
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   ENCARG(fold) -> c
   ENCARG(nil) -> c1
   ENCARG(cons) -> c2
   ENCARG(plus) -> c3
   ENCARG(0) -> c4
   ENCARG(s) -> c5
   ENCARG(times) -> c6
   ENCARG(add) -> c7
   ENCARG(mul) -> c8
   ENCARG(cons_app(z0, z1)) -> c9(APP(encArg(z0), encArg(z1)), ENCARG(z0), ENCARG(z1))
   ENCARG(cons_sum) -> c10(SUM)
   ENCARG(cons_prod) -> c11(PROD)
   ENCODE_APP(z0, z1) -> c12(APP(encArg(z0), encArg(z1)), ENCARG(z0), ENCARG(z1))
   ENCODE_FOLD -> c13
   ENCODE_NIL -> c14
   ENCODE_CONS -> c15
   ENCODE_PLUS -> c16
   ENCODE_0 -> c17
   ENCODE_S -> c18
   ENCODE_TIMES -> c19
   ENCODE_SUM -> c20(SUM)
   ENCODE_ADD -> c21
   ENCODE_PROD -> c22(PROD)
   ENCODE_MUL -> c23
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3), APP(app(fold, z0), z1), APP(fold, z0))
   APP(app(plus, 0), z0) -> c26
   APP(app(plus, app(s, z0)), z1) -> c27(APP(s, app(app(plus, z0), z1)), APP(app(plus, z0), z1), APP(plus, z0))
   APP(app(times, 0), z0) -> c28
   APP(app(times, app(s, z0)), z1) -> c29(APP(app(plus, app(app(times, z0), z1)), z1), APP(plus, app(app(times, z0), z1)), APP(app(times, z0), z1), APP(times, z0))
   SUM -> c30(APP(app(fold, add), 0), APP(fold, add))
   PROD -> c31(APP(app(fold, mul), app(s, 0)), APP(fold, mul), APP(s, 0))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3), APP(app(fold, z0), z1), APP(fold, z0))
   APP(app(plus, 0), z0) -> c26
   APP(app(plus, app(s, z0)), z1) -> c27(APP(s, app(app(plus, z0), z1)), APP(app(plus, z0), z1), APP(plus, z0))
   APP(app(times, 0), z0) -> c28
   APP(app(times, app(s, z0)), z1) -> c29(APP(app(plus, app(app(times, z0), z1)), z1), APP(plus, app(app(times, z0), z1)), APP(app(times, z0), z1), APP(times, z0))
   SUM -> c30(APP(app(fold, add), 0), APP(fold, add))
   PROD -> c31(APP(app(fold, mul), app(s, 0)), APP(fold, mul), APP(s, 0))
K tuples:none
Defined Rule Symbols:   app_2, sum, prod, encArg_1, encode_app_2, encode_fold, encode_nil, encode_cons, encode_plus, encode_0, encode_s, encode_times, encode_sum, encode_add, encode_prod, encode_mul

Defined Pair Symbols:   ENCARG_1, ENCODE_APP_2, ENCODE_FOLD, ENCODE_NIL, ENCODE_CONS, ENCODE_PLUS, ENCODE_0, ENCODE_S, ENCODE_TIMES, ENCODE_SUM, ENCODE_ADD, ENCODE_PROD, ENCODE_MUL, APP_2, SUM, PROD

Compound Symbols:   c, c1, c2, c3, c4, c5, c6, c7, c8, c9_3, c10_1, c11_1, c12_3, c13, c14, c15, c16, c17, c18, c19, c20_1, c21, c22_1, c23, c24, c25_5, c26, c27_3, c28, c29_4, c30_2, c31_3


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

(37) CdtLeafRemovalProof (ComplexityIfPolyImplication)
Removed 2 leading nodes:
   ENCODE_SUM -> c20(SUM)
   ENCODE_PROD -> c22(PROD)
Removed 18 trailing nodes:
   ENCARG(cons) -> c2
   ENCODE_ADD -> c21
   ENCARG(nil) -> c1
   ENCARG(mul) -> c8
   ENCARG(times) -> c6
   ENCARG(fold) -> c
   ENCODE_MUL -> c23
   ENCARG(s) -> c5
   ENCODE_NIL -> c14
   ENCARG(plus) -> c3
   ENCODE_TIMES -> c19
   ENCODE_PLUS -> c16
   ENCODE_FOLD -> c13
   ENCARG(0) -> c4
   ENCODE_0 -> c17
   ENCARG(add) -> c7
   ENCODE_S -> c18
   ENCODE_CONS -> c15

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

(38)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   encode_app(z0, z1) -> app(encArg(z0), encArg(z1))
   encode_fold -> fold
   encode_nil -> nil
   encode_cons -> cons
   encode_plus -> plus
   encode_0 -> 0
   encode_s -> s
   encode_times -> times
   encode_sum -> sum
   encode_add -> add
   encode_prod -> prod
   encode_mul -> mul
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   ENCARG(cons_app(z0, z1)) -> c9(APP(encArg(z0), encArg(z1)), ENCARG(z0), ENCARG(z1))
   ENCARG(cons_sum) -> c10(SUM)
   ENCARG(cons_prod) -> c11(PROD)
   ENCODE_APP(z0, z1) -> c12(APP(encArg(z0), encArg(z1)), ENCARG(z0), ENCARG(z1))
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3), APP(app(fold, z0), z1), APP(fold, z0))
   APP(app(plus, 0), z0) -> c26
   APP(app(plus, app(s, z0)), z1) -> c27(APP(s, app(app(plus, z0), z1)), APP(app(plus, z0), z1), APP(plus, z0))
   APP(app(times, 0), z0) -> c28
   APP(app(times, app(s, z0)), z1) -> c29(APP(app(plus, app(app(times, z0), z1)), z1), APP(plus, app(app(times, z0), z1)), APP(app(times, z0), z1), APP(times, z0))
   SUM -> c30(APP(app(fold, add), 0), APP(fold, add))
   PROD -> c31(APP(app(fold, mul), app(s, 0)), APP(fold, mul), APP(s, 0))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3), APP(app(fold, z0), z1), APP(fold, z0))
   APP(app(plus, 0), z0) -> c26
   APP(app(plus, app(s, z0)), z1) -> c27(APP(s, app(app(plus, z0), z1)), APP(app(plus, z0), z1), APP(plus, z0))
   APP(app(times, 0), z0) -> c28
   APP(app(times, app(s, z0)), z1) -> c29(APP(app(plus, app(app(times, z0), z1)), z1), APP(plus, app(app(times, z0), z1)), APP(app(times, z0), z1), APP(times, z0))
   SUM -> c30(APP(app(fold, add), 0), APP(fold, add))
   PROD -> c31(APP(app(fold, mul), app(s, 0)), APP(fold, mul), APP(s, 0))
K tuples:none
Defined Rule Symbols:   app_2, sum, prod, encArg_1, encode_app_2, encode_fold, encode_nil, encode_cons, encode_plus, encode_0, encode_s, encode_times, encode_sum, encode_add, encode_prod, encode_mul

Defined Pair Symbols:   ENCARG_1, ENCODE_APP_2, APP_2, SUM, PROD

Compound Symbols:   c9_3, c10_1, c11_1, c12_3, c24, c25_5, c26, c27_3, c28, c29_4, c30_2, c31_3


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

(39) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 11 trailing tuple parts
----------------------------------------

(40)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   encode_app(z0, z1) -> app(encArg(z0), encArg(z1))
   encode_fold -> fold
   encode_nil -> nil
   encode_cons -> cons
   encode_plus -> plus
   encode_0 -> 0
   encode_s -> s
   encode_times -> times
   encode_sum -> sum
   encode_add -> add
   encode_prod -> prod
   encode_mul -> mul
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   ENCARG(cons_app(z0, z1)) -> c9(APP(encArg(z0), encArg(z1)), ENCARG(z0), ENCARG(z1))
   ENCARG(cons_sum) -> c10(SUM)
   ENCARG(cons_prod) -> c11(PROD)
   ENCODE_APP(z0, z1) -> c12(APP(encArg(z0), encArg(z1)), ENCARG(z0), ENCARG(z1))
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, z0)), z1) -> c29(APP(app(plus, app(app(times, z0), z1)), z1), APP(app(times, z0), z1))
   SUM -> c30
   PROD -> c31
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, z0)), z1) -> c29(APP(app(plus, app(app(times, z0), z1)), z1), APP(app(times, z0), z1))
   SUM -> c30
   PROD -> c31
K tuples:none
Defined Rule Symbols:   app_2, sum, prod, encArg_1, encode_app_2, encode_fold, encode_nil, encode_cons, encode_plus, encode_0, encode_s, encode_times, encode_sum, encode_add, encode_prod, encode_mul

Defined Pair Symbols:   ENCARG_1, ENCODE_APP_2, APP_2, SUM, PROD

Compound Symbols:   c9_3, c10_1, c11_1, c12_3, c24, c26, c28, c25_3, c27_1, c29_2, c30, c31


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

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

(42)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   encode_app(z0, z1) -> app(encArg(z0), encArg(z1))
   encode_fold -> fold
   encode_nil -> nil
   encode_cons -> cons
   encode_plus -> plus
   encode_0 -> 0
   encode_s -> s
   encode_times -> times
   encode_sum -> sum
   encode_add -> add
   encode_prod -> prod
   encode_mul -> mul
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   ENCARG(cons_app(z0, z1)) -> c9(APP(encArg(z0), encArg(z1)), ENCARG(z0), ENCARG(z1))
   ENCARG(cons_sum) -> c10(SUM)
   ENCARG(cons_prod) -> c11(PROD)
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, z0)), z1) -> c29(APP(app(plus, app(app(times, z0), z1)), z1), APP(app(times, z0), z1))
   SUM -> c30
   PROD -> c31
   ENCODE_APP(z0, z1) -> c(APP(encArg(z0), encArg(z1)))
   ENCODE_APP(z0, z1) -> c(ENCARG(z0))
   ENCODE_APP(z0, z1) -> c(ENCARG(z1))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, z0)), z1) -> c29(APP(app(plus, app(app(times, z0), z1)), z1), APP(app(times, z0), z1))
   SUM -> c30
   PROD -> c31
K tuples:none
Defined Rule Symbols:   app_2, sum, prod, encArg_1, encode_app_2, encode_fold, encode_nil, encode_cons, encode_plus, encode_0, encode_s, encode_times, encode_sum, encode_add, encode_prod, encode_mul

Defined Pair Symbols:   ENCARG_1, APP_2, SUM, PROD, ENCODE_APP_2

Compound Symbols:   c9_3, c10_1, c11_1, c24, c26, c28, c25_3, c27_1, c29_2, c30, c31, c_1


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

(43) CdtLeafRemovalProof (ComplexityIfPolyImplication)
Removed 2 leading nodes:
   ENCODE_APP(z0, z1) -> c(ENCARG(z0))
   ENCODE_APP(z0, z1) -> c(ENCARG(z1))

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

(44)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   encode_app(z0, z1) -> app(encArg(z0), encArg(z1))
   encode_fold -> fold
   encode_nil -> nil
   encode_cons -> cons
   encode_plus -> plus
   encode_0 -> 0
   encode_s -> s
   encode_times -> times
   encode_sum -> sum
   encode_add -> add
   encode_prod -> prod
   encode_mul -> mul
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   ENCARG(cons_app(z0, z1)) -> c9(APP(encArg(z0), encArg(z1)), ENCARG(z0), ENCARG(z1))
   ENCARG(cons_sum) -> c10(SUM)
   ENCARG(cons_prod) -> c11(PROD)
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, z0)), z1) -> c29(APP(app(plus, app(app(times, z0), z1)), z1), APP(app(times, z0), z1))
   SUM -> c30
   PROD -> c31
   ENCODE_APP(z0, z1) -> c(APP(encArg(z0), encArg(z1)))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, z0)), z1) -> c29(APP(app(plus, app(app(times, z0), z1)), z1), APP(app(times, z0), z1))
   SUM -> c30
   PROD -> c31
K tuples:none
Defined Rule Symbols:   app_2, sum, prod, encArg_1, encode_app_2, encode_fold, encode_nil, encode_cons, encode_plus, encode_0, encode_s, encode_times, encode_sum, encode_add, encode_prod, encode_mul

Defined Pair Symbols:   ENCARG_1, APP_2, SUM, PROD, ENCODE_APP_2

Compound Symbols:   c9_3, c10_1, c11_1, c24, c26, c28, c25_3, c27_1, c29_2, c30, c31, c_1


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

(45) CdtUsableRulesProof (BOTH BOUNDS(ID, ID))
The following rules are not usable and were removed:
   encode_app(z0, z1) -> app(encArg(z0), encArg(z1))
   encode_fold -> fold
   encode_nil -> nil
   encode_cons -> cons
   encode_plus -> plus
   encode_0 -> 0
   encode_s -> s
   encode_times -> times
   encode_sum -> sum
   encode_add -> add
   encode_prod -> prod
   encode_mul -> mul

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

(46)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   ENCARG(cons_app(z0, z1)) -> c9(APP(encArg(z0), encArg(z1)), ENCARG(z0), ENCARG(z1))
   ENCARG(cons_sum) -> c10(SUM)
   ENCARG(cons_prod) -> c11(PROD)
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, z0)), z1) -> c29(APP(app(plus, app(app(times, z0), z1)), z1), APP(app(times, z0), z1))
   SUM -> c30
   PROD -> c31
   ENCODE_APP(z0, z1) -> c(APP(encArg(z0), encArg(z1)))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, z0)), z1) -> c29(APP(app(plus, app(app(times, z0), z1)), z1), APP(app(times, z0), z1))
   SUM -> c30
   PROD -> c31
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   ENCARG_1, APP_2, SUM, PROD, ENCODE_APP_2

Compound Symbols:   c9_3, c10_1, c11_1, c24, c26, c28, c25_3, c27_1, c29_2, c30, c31, c_1


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

(47) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   SUM -> c30
   PROD -> c31
We considered the (Usable) Rules:none
And the Tuples:
   ENCARG(cons_app(z0, z1)) -> c9(APP(encArg(z0), encArg(z1)), ENCARG(z0), ENCARG(z1))
   ENCARG(cons_sum) -> c10(SUM)
   ENCARG(cons_prod) -> c11(PROD)
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, z0)), z1) -> c29(APP(app(plus, app(app(times, z0), z1)), z1), APP(app(times, z0), z1))
   SUM -> c30
   PROD -> c31
   ENCODE_APP(z0, z1) -> c(APP(encArg(z0), encArg(z1)))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(0) = 0
   POL(APP(x_1, x_2)) = 0
   POL(ENCARG(x_1)) = [1] + x_1
   POL(ENCODE_APP(x_1, x_2)) = 0
   POL(PROD) = [1]
   POL(SUM) = [1]
   POL(add) = [1]
   POL(app(x_1, x_2)) = x_1 + x_2
   POL(c(x_1)) = x_1
   POL(c10(x_1)) = x_1
   POL(c11(x_1)) = x_1
   POL(c24) = 0
   POL(c25(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(c26) = 0
   POL(c27(x_1)) = x_1
   POL(c28) = 0
   POL(c29(x_1, x_2)) = x_1 + x_2
   POL(c30) = 0
   POL(c31) = 0
   POL(c9(x_1, x_2, x_3)) = x_1 + x_2 + x_3
   POL(cons) = [1]
   POL(cons_app(x_1, x_2)) = [1] + x_1 + x_2
   POL(cons_prod) = 0
   POL(cons_sum) = 0
   POL(encArg(x_1)) = [1] + x_1
   POL(fold) = 0
   POL(mul) = [1]
   POL(nil) = [1]
   POL(plus) = [1]
   POL(prod) = [1]
   POL(s) = 0
   POL(sum) = [1]
   POL(times) = [1]

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

(48)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   ENCARG(cons_app(z0, z1)) -> c9(APP(encArg(z0), encArg(z1)), ENCARG(z0), ENCARG(z1))
   ENCARG(cons_sum) -> c10(SUM)
   ENCARG(cons_prod) -> c11(PROD)
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, z0)), z1) -> c29(APP(app(plus, app(app(times, z0), z1)), z1), APP(app(times, z0), z1))
   SUM -> c30
   PROD -> c31
   ENCODE_APP(z0, z1) -> c(APP(encArg(z0), encArg(z1)))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, z0)), z1) -> c29(APP(app(plus, app(app(times, z0), z1)), z1), APP(app(times, z0), z1))
K tuples:
   SUM -> c30
   PROD -> c31
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   ENCARG_1, APP_2, SUM, PROD, ENCODE_APP_2

Compound Symbols:   c9_3, c10_1, c11_1, c24, c26, c28, c25_3, c27_1, c29_2, c30, c31, c_1


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

(49) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace ENCARG(cons_app(z0, z1)) -> c9(APP(encArg(z0), encArg(z1)), ENCARG(z0), ENCARG(z1)) by 
   ENCARG(cons_app(x0, fold)) -> c9(APP(encArg(x0), fold), ENCARG(x0), ENCARG(fold))
   ENCARG(cons_app(x0, nil)) -> c9(APP(encArg(x0), nil), ENCARG(x0), ENCARG(nil))
   ENCARG(cons_app(x0, cons)) -> c9(APP(encArg(x0), cons), ENCARG(x0), ENCARG(cons))
   ENCARG(cons_app(x0, plus)) -> c9(APP(encArg(x0), plus), ENCARG(x0), ENCARG(plus))
   ENCARG(cons_app(x0, 0)) -> c9(APP(encArg(x0), 0), ENCARG(x0), ENCARG(0))
   ENCARG(cons_app(x0, s)) -> c9(APP(encArg(x0), s), ENCARG(x0), ENCARG(s))
   ENCARG(cons_app(x0, times)) -> c9(APP(encArg(x0), times), ENCARG(x0), ENCARG(times))
   ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0), ENCARG(add))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0), ENCARG(mul))
   ENCARG(cons_app(x0, cons_app(z0, z1))) -> c9(APP(encArg(x0), app(encArg(z0), encArg(z1))), ENCARG(x0), ENCARG(cons_app(z0, z1)))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0), ENCARG(cons_sum))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0), ENCARG(cons_prod))
   ENCARG(cons_app(fold, x1)) -> c9(APP(fold, encArg(x1)), ENCARG(fold), ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(APP(nil, encArg(x1)), ENCARG(nil), ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(APP(cons, encArg(x1)), ENCARG(cons), ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(APP(plus, encArg(x1)), ENCARG(plus), ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(APP(0, encArg(x1)), ENCARG(0), ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(APP(s, encArg(x1)), ENCARG(s), ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(APP(times, encArg(x1)), ENCARG(times), ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(APP(add, encArg(x1)), ENCARG(add), ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(APP(mul, encArg(x1)), ENCARG(mul), ENCARG(x1))
   ENCARG(cons_app(cons_app(z0, z1), x1)) -> c9(APP(app(encArg(z0), encArg(z1)), encArg(x1)), ENCARG(cons_app(z0, z1)), ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(cons_sum), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(cons_prod), ENCARG(x1))

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

(50)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   ENCARG(cons_sum) -> c10(SUM)
   ENCARG(cons_prod) -> c11(PROD)
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, z0)), z1) -> c29(APP(app(plus, app(app(times, z0), z1)), z1), APP(app(times, z0), z1))
   SUM -> c30
   PROD -> c31
   ENCODE_APP(z0, z1) -> c(APP(encArg(z0), encArg(z1)))
   ENCARG(cons_app(x0, fold)) -> c9(APP(encArg(x0), fold), ENCARG(x0), ENCARG(fold))
   ENCARG(cons_app(x0, nil)) -> c9(APP(encArg(x0), nil), ENCARG(x0), ENCARG(nil))
   ENCARG(cons_app(x0, cons)) -> c9(APP(encArg(x0), cons), ENCARG(x0), ENCARG(cons))
   ENCARG(cons_app(x0, plus)) -> c9(APP(encArg(x0), plus), ENCARG(x0), ENCARG(plus))
   ENCARG(cons_app(x0, 0)) -> c9(APP(encArg(x0), 0), ENCARG(x0), ENCARG(0))
   ENCARG(cons_app(x0, s)) -> c9(APP(encArg(x0), s), ENCARG(x0), ENCARG(s))
   ENCARG(cons_app(x0, times)) -> c9(APP(encArg(x0), times), ENCARG(x0), ENCARG(times))
   ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0), ENCARG(add))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0), ENCARG(mul))
   ENCARG(cons_app(x0, cons_app(z0, z1))) -> c9(APP(encArg(x0), app(encArg(z0), encArg(z1))), ENCARG(x0), ENCARG(cons_app(z0, z1)))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0), ENCARG(cons_sum))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0), ENCARG(cons_prod))
   ENCARG(cons_app(fold, x1)) -> c9(APP(fold, encArg(x1)), ENCARG(fold), ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(APP(nil, encArg(x1)), ENCARG(nil), ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(APP(cons, encArg(x1)), ENCARG(cons), ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(APP(plus, encArg(x1)), ENCARG(plus), ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(APP(0, encArg(x1)), ENCARG(0), ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(APP(s, encArg(x1)), ENCARG(s), ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(APP(times, encArg(x1)), ENCARG(times), ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(APP(add, encArg(x1)), ENCARG(add), ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(APP(mul, encArg(x1)), ENCARG(mul), ENCARG(x1))
   ENCARG(cons_app(cons_app(z0, z1), x1)) -> c9(APP(app(encArg(z0), encArg(z1)), encArg(x1)), ENCARG(cons_app(z0, z1)), ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(cons_sum), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(cons_prod), ENCARG(x1))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, z0)), z1) -> c29(APP(app(plus, app(app(times, z0), z1)), z1), APP(app(times, z0), z1))
K tuples:
   SUM -> c30
   PROD -> c31
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   ENCARG_1, APP_2, SUM, PROD, ENCODE_APP_2

Compound Symbols:   c10_1, c11_1, c24, c26, c28, c25_3, c27_1, c29_2, c30, c31, c_1, c9_3


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

(51) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 4 trailing nodes:
   SUM -> c30
   ENCARG(cons_sum) -> c10(SUM)
   PROD -> c31
   ENCARG(cons_prod) -> c11(PROD)

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

(52)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, z0)), z1) -> c29(APP(app(plus, app(app(times, z0), z1)), z1), APP(app(times, z0), z1))
   ENCODE_APP(z0, z1) -> c(APP(encArg(z0), encArg(z1)))
   ENCARG(cons_app(x0, fold)) -> c9(APP(encArg(x0), fold), ENCARG(x0), ENCARG(fold))
   ENCARG(cons_app(x0, nil)) -> c9(APP(encArg(x0), nil), ENCARG(x0), ENCARG(nil))
   ENCARG(cons_app(x0, cons)) -> c9(APP(encArg(x0), cons), ENCARG(x0), ENCARG(cons))
   ENCARG(cons_app(x0, plus)) -> c9(APP(encArg(x0), plus), ENCARG(x0), ENCARG(plus))
   ENCARG(cons_app(x0, 0)) -> c9(APP(encArg(x0), 0), ENCARG(x0), ENCARG(0))
   ENCARG(cons_app(x0, s)) -> c9(APP(encArg(x0), s), ENCARG(x0), ENCARG(s))
   ENCARG(cons_app(x0, times)) -> c9(APP(encArg(x0), times), ENCARG(x0), ENCARG(times))
   ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0), ENCARG(add))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0), ENCARG(mul))
   ENCARG(cons_app(x0, cons_app(z0, z1))) -> c9(APP(encArg(x0), app(encArg(z0), encArg(z1))), ENCARG(x0), ENCARG(cons_app(z0, z1)))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0), ENCARG(cons_sum))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0), ENCARG(cons_prod))
   ENCARG(cons_app(fold, x1)) -> c9(APP(fold, encArg(x1)), ENCARG(fold), ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(APP(nil, encArg(x1)), ENCARG(nil), ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(APP(cons, encArg(x1)), ENCARG(cons), ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(APP(plus, encArg(x1)), ENCARG(plus), ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(APP(0, encArg(x1)), ENCARG(0), ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(APP(s, encArg(x1)), ENCARG(s), ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(APP(times, encArg(x1)), ENCARG(times), ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(APP(add, encArg(x1)), ENCARG(add), ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(APP(mul, encArg(x1)), ENCARG(mul), ENCARG(x1))
   ENCARG(cons_app(cons_app(z0, z1), x1)) -> c9(APP(app(encArg(z0), encArg(z1)), encArg(x1)), ENCARG(cons_app(z0, z1)), ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(cons_sum), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(cons_prod), ENCARG(x1))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, z0)), z1) -> c29(APP(app(plus, app(app(times, z0), z1)), z1), APP(app(times, z0), z1))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCODE_APP_2, ENCARG_1

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c29_2, c_1, c9_3


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

(53) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 31 trailing tuple parts
----------------------------------------

(54)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, z0)), z1) -> c29(APP(app(plus, app(app(times, z0), z1)), z1), APP(app(times, z0), z1))
   ENCODE_APP(z0, z1) -> c(APP(encArg(z0), encArg(z1)))
   ENCARG(cons_app(x0, cons_app(z0, z1))) -> c9(APP(encArg(x0), app(encArg(z0), encArg(z1))), ENCARG(x0), ENCARG(cons_app(z0, z1)))
   ENCARG(cons_app(cons_app(z0, z1), x1)) -> c9(APP(app(encArg(z0), encArg(z1)), encArg(x1)), ENCARG(cons_app(z0, z1)), ENCARG(x1))
   ENCARG(cons_app(x0, fold)) -> c9(APP(encArg(x0), fold), ENCARG(x0))
   ENCARG(cons_app(x0, nil)) -> c9(APP(encArg(x0), nil), ENCARG(x0))
   ENCARG(cons_app(x0, cons)) -> c9(APP(encArg(x0), cons), ENCARG(x0))
   ENCARG(cons_app(x0, plus)) -> c9(APP(encArg(x0), plus), ENCARG(x0))
   ENCARG(cons_app(x0, 0)) -> c9(APP(encArg(x0), 0), ENCARG(x0))
   ENCARG(cons_app(x0, s)) -> c9(APP(encArg(x0), s), ENCARG(x0))
   ENCARG(cons_app(x0, times)) -> c9(APP(encArg(x0), times), ENCARG(x0))
   ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, z0)), z1) -> c29(APP(app(plus, app(app(times, z0), z1)), z1), APP(app(times, z0), z1))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCODE_APP_2, ENCARG_1

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c29_2, c_1, c9_3, c9_2, c9_1


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

(55) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace APP(app(times, app(s, z0)), z1) -> c29(APP(app(plus, app(app(times, z0), z1)), z1), APP(app(times, z0), z1)) by 
   APP(app(times, app(s, 0)), z0) -> c29(APP(app(plus, 0), z0), APP(app(times, 0), z0))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))

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

(56)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCODE_APP(z0, z1) -> c(APP(encArg(z0), encArg(z1)))
   ENCARG(cons_app(x0, cons_app(z0, z1))) -> c9(APP(encArg(x0), app(encArg(z0), encArg(z1))), ENCARG(x0), ENCARG(cons_app(z0, z1)))
   ENCARG(cons_app(cons_app(z0, z1), x1)) -> c9(APP(app(encArg(z0), encArg(z1)), encArg(x1)), ENCARG(cons_app(z0, z1)), ENCARG(x1))
   ENCARG(cons_app(x0, fold)) -> c9(APP(encArg(x0), fold), ENCARG(x0))
   ENCARG(cons_app(x0, nil)) -> c9(APP(encArg(x0), nil), ENCARG(x0))
   ENCARG(cons_app(x0, cons)) -> c9(APP(encArg(x0), cons), ENCARG(x0))
   ENCARG(cons_app(x0, plus)) -> c9(APP(encArg(x0), plus), ENCARG(x0))
   ENCARG(cons_app(x0, 0)) -> c9(APP(encArg(x0), 0), ENCARG(x0))
   ENCARG(cons_app(x0, s)) -> c9(APP(encArg(x0), s), ENCARG(x0))
   ENCARG(cons_app(x0, times)) -> c9(APP(encArg(x0), times), ENCARG(x0))
   ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, 0)), z0) -> c29(APP(app(plus, 0), z0), APP(app(times, 0), z0))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, 0)), z0) -> c29(APP(app(plus, 0), z0), APP(app(times, 0), z0))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCODE_APP_2, ENCARG_1

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c_1, c9_3, c9_2, c9_1, c29_2


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

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

(58)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCODE_APP(z0, z1) -> c(APP(encArg(z0), encArg(z1)))
   ENCARG(cons_app(x0, cons_app(z0, z1))) -> c9(APP(encArg(x0), app(encArg(z0), encArg(z1))), ENCARG(x0), ENCARG(cons_app(z0, z1)))
   ENCARG(cons_app(cons_app(z0, z1), x1)) -> c9(APP(app(encArg(z0), encArg(z1)), encArg(x1)), ENCARG(cons_app(z0, z1)), ENCARG(x1))
   ENCARG(cons_app(x0, fold)) -> c9(APP(encArg(x0), fold), ENCARG(x0))
   ENCARG(cons_app(x0, nil)) -> c9(APP(encArg(x0), nil), ENCARG(x0))
   ENCARG(cons_app(x0, cons)) -> c9(APP(encArg(x0), cons), ENCARG(x0))
   ENCARG(cons_app(x0, plus)) -> c9(APP(encArg(x0), plus), ENCARG(x0))
   ENCARG(cons_app(x0, 0)) -> c9(APP(encArg(x0), 0), ENCARG(x0))
   ENCARG(cons_app(x0, s)) -> c9(APP(encArg(x0), s), ENCARG(x0))
   ENCARG(cons_app(x0, times)) -> c9(APP(encArg(x0), times), ENCARG(x0))
   ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCODE_APP_2, ENCARG_1

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c_1, c9_3, c9_2, c9_1, c29_2, c1_1


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

(59) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace ENCODE_APP(z0, z1) -> c(APP(encArg(z0), encArg(z1))) by 
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(fold, x1) -> c(APP(fold, encArg(x1)))
   ENCODE_APP(nil, x1) -> c(APP(nil, encArg(x1)))
   ENCODE_APP(cons, x1) -> c(APP(cons, encArg(x1)))
   ENCODE_APP(plus, x1) -> c(APP(plus, encArg(x1)))
   ENCODE_APP(0, x1) -> c(APP(0, encArg(x1)))
   ENCODE_APP(s, x1) -> c(APP(s, encArg(x1)))
   ENCODE_APP(times, x1) -> c(APP(times, encArg(x1)))
   ENCODE_APP(add, x1) -> c(APP(add, encArg(x1)))
   ENCODE_APP(mul, x1) -> c(APP(mul, encArg(x1)))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))

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

(60)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, cons_app(z0, z1))) -> c9(APP(encArg(x0), app(encArg(z0), encArg(z1))), ENCARG(x0), ENCARG(cons_app(z0, z1)))
   ENCARG(cons_app(cons_app(z0, z1), x1)) -> c9(APP(app(encArg(z0), encArg(z1)), encArg(x1)), ENCARG(cons_app(z0, z1)), ENCARG(x1))
   ENCARG(cons_app(x0, fold)) -> c9(APP(encArg(x0), fold), ENCARG(x0))
   ENCARG(cons_app(x0, nil)) -> c9(APP(encArg(x0), nil), ENCARG(x0))
   ENCARG(cons_app(x0, cons)) -> c9(APP(encArg(x0), cons), ENCARG(x0))
   ENCARG(cons_app(x0, plus)) -> c9(APP(encArg(x0), plus), ENCARG(x0))
   ENCARG(cons_app(x0, 0)) -> c9(APP(encArg(x0), 0), ENCARG(x0))
   ENCARG(cons_app(x0, s)) -> c9(APP(encArg(x0), s), ENCARG(x0))
   ENCARG(cons_app(x0, times)) -> c9(APP(encArg(x0), times), ENCARG(x0))
   ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(fold, x1) -> c(APP(fold, encArg(x1)))
   ENCODE_APP(nil, x1) -> c(APP(nil, encArg(x1)))
   ENCODE_APP(cons, x1) -> c(APP(cons, encArg(x1)))
   ENCODE_APP(plus, x1) -> c(APP(plus, encArg(x1)))
   ENCODE_APP(0, x1) -> c(APP(0, encArg(x1)))
   ENCODE_APP(s, x1) -> c(APP(s, encArg(x1)))
   ENCODE_APP(times, x1) -> c(APP(times, encArg(x1)))
   ENCODE_APP(add, x1) -> c(APP(add, encArg(x1)))
   ENCODE_APP(mul, x1) -> c(APP(mul, encArg(x1)))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_3, c9_2, c9_1, c29_2, c1_1, c_1


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

(61) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 9 trailing nodes:
   ENCODE_APP(times, x1) -> c(APP(times, encArg(x1)))
   ENCODE_APP(mul, x1) -> c(APP(mul, encArg(x1)))
   ENCODE_APP(s, x1) -> c(APP(s, encArg(x1)))
   ENCODE_APP(cons, x1) -> c(APP(cons, encArg(x1)))
   ENCODE_APP(nil, x1) -> c(APP(nil, encArg(x1)))
   ENCODE_APP(0, x1) -> c(APP(0, encArg(x1)))
   ENCODE_APP(fold, x1) -> c(APP(fold, encArg(x1)))
   ENCODE_APP(plus, x1) -> c(APP(plus, encArg(x1)))
   ENCODE_APP(add, x1) -> c(APP(add, encArg(x1)))

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

(62)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, cons_app(z0, z1))) -> c9(APP(encArg(x0), app(encArg(z0), encArg(z1))), ENCARG(x0), ENCARG(cons_app(z0, z1)))
   ENCARG(cons_app(cons_app(z0, z1), x1)) -> c9(APP(app(encArg(z0), encArg(z1)), encArg(x1)), ENCARG(cons_app(z0, z1)), ENCARG(x1))
   ENCARG(cons_app(x0, fold)) -> c9(APP(encArg(x0), fold), ENCARG(x0))
   ENCARG(cons_app(x0, nil)) -> c9(APP(encArg(x0), nil), ENCARG(x0))
   ENCARG(cons_app(x0, cons)) -> c9(APP(encArg(x0), cons), ENCARG(x0))
   ENCARG(cons_app(x0, plus)) -> c9(APP(encArg(x0), plus), ENCARG(x0))
   ENCARG(cons_app(x0, 0)) -> c9(APP(encArg(x0), 0), ENCARG(x0))
   ENCARG(cons_app(x0, s)) -> c9(APP(encArg(x0), s), ENCARG(x0))
   ENCARG(cons_app(x0, times)) -> c9(APP(encArg(x0), times), ENCARG(x0))
   ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_3, c9_2, c9_1, c29_2, c1_1, c_1


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

(63) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace ENCARG(cons_app(x0, cons_app(z0, z1))) -> c9(APP(encArg(x0), app(encArg(z0), encArg(z1))), ENCARG(x0), ENCARG(cons_app(z0, z1))) by 
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(APP(fold, app(encArg(x1), encArg(x2))), ENCARG(fold), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(APP(nil, app(encArg(x1), encArg(x2))), ENCARG(nil), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(APP(cons, app(encArg(x1), encArg(x2))), ENCARG(cons), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(APP(plus, app(encArg(x1), encArg(x2))), ENCARG(plus), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(APP(0, app(encArg(x1), encArg(x2))), ENCARG(0), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(APP(s, app(encArg(x1), encArg(x2))), ENCARG(s), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(APP(times, app(encArg(x1), encArg(x2))), ENCARG(times), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(APP(add, app(encArg(x1), encArg(x2))), ENCARG(add), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(APP(mul, app(encArg(x1), encArg(x2))), ENCARG(mul), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_sum), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_prod), ENCARG(cons_app(x1, x2)))

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

(64)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(cons_app(z0, z1), x1)) -> c9(APP(app(encArg(z0), encArg(z1)), encArg(x1)), ENCARG(cons_app(z0, z1)), ENCARG(x1))
   ENCARG(cons_app(x0, fold)) -> c9(APP(encArg(x0), fold), ENCARG(x0))
   ENCARG(cons_app(x0, nil)) -> c9(APP(encArg(x0), nil), ENCARG(x0))
   ENCARG(cons_app(x0, cons)) -> c9(APP(encArg(x0), cons), ENCARG(x0))
   ENCARG(cons_app(x0, plus)) -> c9(APP(encArg(x0), plus), ENCARG(x0))
   ENCARG(cons_app(x0, 0)) -> c9(APP(encArg(x0), 0), ENCARG(x0))
   ENCARG(cons_app(x0, s)) -> c9(APP(encArg(x0), s), ENCARG(x0))
   ENCARG(cons_app(x0, times)) -> c9(APP(encArg(x0), times), ENCARG(x0))
   ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(APP(fold, app(encArg(x1), encArg(x2))), ENCARG(fold), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(APP(nil, app(encArg(x1), encArg(x2))), ENCARG(nil), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(APP(cons, app(encArg(x1), encArg(x2))), ENCARG(cons), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(APP(plus, app(encArg(x1), encArg(x2))), ENCARG(plus), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(APP(0, app(encArg(x1), encArg(x2))), ENCARG(0), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(APP(s, app(encArg(x1), encArg(x2))), ENCARG(s), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(APP(times, app(encArg(x1), encArg(x2))), ENCARG(times), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(APP(add, app(encArg(x1), encArg(x2))), ENCARG(add), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(APP(mul, app(encArg(x1), encArg(x2))), ENCARG(mul), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_sum), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_prod), ENCARG(cons_app(x1, x2)))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_3, c9_2, c9_1, c29_2, c1_1, c_1


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

(65) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 20 trailing tuple parts
----------------------------------------

(66)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(cons_app(z0, z1), x1)) -> c9(APP(app(encArg(z0), encArg(z1)), encArg(x1)), ENCARG(cons_app(z0, z1)), ENCARG(x1))
   ENCARG(cons_app(x0, fold)) -> c9(APP(encArg(x0), fold), ENCARG(x0))
   ENCARG(cons_app(x0, nil)) -> c9(APP(encArg(x0), nil), ENCARG(x0))
   ENCARG(cons_app(x0, cons)) -> c9(APP(encArg(x0), cons), ENCARG(x0))
   ENCARG(cons_app(x0, plus)) -> c9(APP(encArg(x0), plus), ENCARG(x0))
   ENCARG(cons_app(x0, 0)) -> c9(APP(encArg(x0), 0), ENCARG(x0))
   ENCARG(cons_app(x0, s)) -> c9(APP(encArg(x0), s), ENCARG(x0))
   ENCARG(cons_app(x0, times)) -> c9(APP(encArg(x0), times), ENCARG(x0))
   ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_3, c9_2, c9_1, c29_2, c1_1, c_1


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

(67) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace ENCARG(cons_app(cons_app(z0, z1), x1)) -> c9(APP(app(encArg(z0), encArg(z1)), encArg(x1)), ENCARG(cons_app(z0, z1)), ENCARG(x1)) by 
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)), ENCARG(fold))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)), ENCARG(nil))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)), ENCARG(cons))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)), ENCARG(plus))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)), ENCARG(0))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)), ENCARG(s))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)), ENCARG(times))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)), ENCARG(add))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)), ENCARG(mul))
   ENCARG(cons_app(cons_app(x0, x1), cons_app(z0, z1))) -> c9(APP(app(encArg(x0), encArg(x1)), app(encArg(z0), encArg(z1))), ENCARG(cons_app(x0, x1)), ENCARG(cons_app(z0, z1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)), ENCARG(cons_sum))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)), ENCARG(cons_prod))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(APP(app(fold, encArg(x1)), encArg(x2)), ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(APP(app(nil, encArg(x1)), encArg(x2)), ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(APP(app(cons, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(APP(app(0, encArg(x1)), encArg(x2)), ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(APP(app(s, encArg(x1)), encArg(x2)), ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(APP(app(add, encArg(x1)), encArg(x2)), ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(APP(app(mul, encArg(x1)), encArg(x2)), ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))

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

(68)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, fold)) -> c9(APP(encArg(x0), fold), ENCARG(x0))
   ENCARG(cons_app(x0, nil)) -> c9(APP(encArg(x0), nil), ENCARG(x0))
   ENCARG(cons_app(x0, cons)) -> c9(APP(encArg(x0), cons), ENCARG(x0))
   ENCARG(cons_app(x0, plus)) -> c9(APP(encArg(x0), plus), ENCARG(x0))
   ENCARG(cons_app(x0, 0)) -> c9(APP(encArg(x0), 0), ENCARG(x0))
   ENCARG(cons_app(x0, s)) -> c9(APP(encArg(x0), s), ENCARG(x0))
   ENCARG(cons_app(x0, times)) -> c9(APP(encArg(x0), times), ENCARG(x0))
   ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)), ENCARG(fold))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)), ENCARG(nil))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)), ENCARG(cons))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)), ENCARG(plus))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)), ENCARG(0))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)), ENCARG(s))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)), ENCARG(times))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)), ENCARG(add))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)), ENCARG(mul))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)), ENCARG(cons_sum))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)), ENCARG(cons_prod))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(APP(app(fold, encArg(x1)), encArg(x2)), ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(APP(app(nil, encArg(x1)), encArg(x2)), ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(APP(app(cons, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(APP(app(0, encArg(x1)), encArg(x2)), ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(APP(app(s, encArg(x1)), encArg(x2)), ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(APP(app(add, encArg(x1)), encArg(x2)), ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(APP(app(mul, encArg(x1)), encArg(x2)), ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_2, c9_1, c29_2, c1_1, c_1, c9_3


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

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

(70)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, fold)) -> c9(APP(encArg(x0), fold), ENCARG(x0))
   ENCARG(cons_app(x0, nil)) -> c9(APP(encArg(x0), nil), ENCARG(x0))
   ENCARG(cons_app(x0, cons)) -> c9(APP(encArg(x0), cons), ENCARG(x0))
   ENCARG(cons_app(x0, plus)) -> c9(APP(encArg(x0), plus), ENCARG(x0))
   ENCARG(cons_app(x0, 0)) -> c9(APP(encArg(x0), 0), ENCARG(x0))
   ENCARG(cons_app(x0, s)) -> c9(APP(encArg(x0), s), ENCARG(x0))
   ENCARG(cons_app(x0, times)) -> c9(APP(encArg(x0), times), ENCARG(x0))
   ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_2, c9_1, c29_2, c1_1, c_1, c9_3


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

(71) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace ENCARG(cons_app(x0, fold)) -> c9(APP(encArg(x0), fold), ENCARG(x0)) by 
   ENCARG(cons_app(fold, fold)) -> c9(APP(fold, fold), ENCARG(fold))
   ENCARG(cons_app(nil, fold)) -> c9(APP(nil, fold), ENCARG(nil))
   ENCARG(cons_app(cons, fold)) -> c9(APP(cons, fold), ENCARG(cons))
   ENCARG(cons_app(plus, fold)) -> c9(APP(plus, fold), ENCARG(plus))
   ENCARG(cons_app(0, fold)) -> c9(APP(0, fold), ENCARG(0))
   ENCARG(cons_app(s, fold)) -> c9(APP(s, fold), ENCARG(s))
   ENCARG(cons_app(times, fold)) -> c9(APP(times, fold), ENCARG(times))
   ENCARG(cons_app(add, fold)) -> c9(APP(add, fold), ENCARG(add))
   ENCARG(cons_app(mul, fold)) -> c9(APP(mul, fold), ENCARG(mul))
   ENCARG(cons_app(cons_app(z0, z1), fold)) -> c9(APP(app(encArg(z0), encArg(z1)), fold), ENCARG(cons_app(z0, z1)))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold), ENCARG(cons_prod))

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

(72)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, nil)) -> c9(APP(encArg(x0), nil), ENCARG(x0))
   ENCARG(cons_app(x0, cons)) -> c9(APP(encArg(x0), cons), ENCARG(x0))
   ENCARG(cons_app(x0, plus)) -> c9(APP(encArg(x0), plus), ENCARG(x0))
   ENCARG(cons_app(x0, 0)) -> c9(APP(encArg(x0), 0), ENCARG(x0))
   ENCARG(cons_app(x0, s)) -> c9(APP(encArg(x0), s), ENCARG(x0))
   ENCARG(cons_app(x0, times)) -> c9(APP(encArg(x0), times), ENCARG(x0))
   ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(fold, fold)) -> c9(APP(fold, fold), ENCARG(fold))
   ENCARG(cons_app(nil, fold)) -> c9(APP(nil, fold), ENCARG(nil))
   ENCARG(cons_app(cons, fold)) -> c9(APP(cons, fold), ENCARG(cons))
   ENCARG(cons_app(plus, fold)) -> c9(APP(plus, fold), ENCARG(plus))
   ENCARG(cons_app(0, fold)) -> c9(APP(0, fold), ENCARG(0))
   ENCARG(cons_app(s, fold)) -> c9(APP(s, fold), ENCARG(s))
   ENCARG(cons_app(times, fold)) -> c9(APP(times, fold), ENCARG(times))
   ENCARG(cons_app(add, fold)) -> c9(APP(add, fold), ENCARG(add))
   ENCARG(cons_app(mul, fold)) -> c9(APP(mul, fold), ENCARG(mul))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold), ENCARG(cons_prod))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_2, c9_1, c29_2, c1_1, c_1, c9_3


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

(73) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 9 trailing nodes:
   ENCARG(cons_app(fold, fold)) -> c9(APP(fold, fold), ENCARG(fold))
   ENCARG(cons_app(mul, fold)) -> c9(APP(mul, fold), ENCARG(mul))
   ENCARG(cons_app(times, fold)) -> c9(APP(times, fold), ENCARG(times))
   ENCARG(cons_app(add, fold)) -> c9(APP(add, fold), ENCARG(add))
   ENCARG(cons_app(plus, fold)) -> c9(APP(plus, fold), ENCARG(plus))
   ENCARG(cons_app(cons, fold)) -> c9(APP(cons, fold), ENCARG(cons))
   ENCARG(cons_app(s, fold)) -> c9(APP(s, fold), ENCARG(s))
   ENCARG(cons_app(0, fold)) -> c9(APP(0, fold), ENCARG(0))
   ENCARG(cons_app(nil, fold)) -> c9(APP(nil, fold), ENCARG(nil))

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

(74)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, nil)) -> c9(APP(encArg(x0), nil), ENCARG(x0))
   ENCARG(cons_app(x0, cons)) -> c9(APP(encArg(x0), cons), ENCARG(x0))
   ENCARG(cons_app(x0, plus)) -> c9(APP(encArg(x0), plus), ENCARG(x0))
   ENCARG(cons_app(x0, 0)) -> c9(APP(encArg(x0), 0), ENCARG(x0))
   ENCARG(cons_app(x0, s)) -> c9(APP(encArg(x0), s), ENCARG(x0))
   ENCARG(cons_app(x0, times)) -> c9(APP(encArg(x0), times), ENCARG(x0))
   ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold), ENCARG(cons_prod))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_2, c9_1, c29_2, c1_1, c_1, c9_3


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

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

(76)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, nil)) -> c9(APP(encArg(x0), nil), ENCARG(x0))
   ENCARG(cons_app(x0, cons)) -> c9(APP(encArg(x0), cons), ENCARG(x0))
   ENCARG(cons_app(x0, plus)) -> c9(APP(encArg(x0), plus), ENCARG(x0))
   ENCARG(cons_app(x0, 0)) -> c9(APP(encArg(x0), 0), ENCARG(x0))
   ENCARG(cons_app(x0, s)) -> c9(APP(encArg(x0), s), ENCARG(x0))
   ENCARG(cons_app(x0, times)) -> c9(APP(encArg(x0), times), ENCARG(x0))
   ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_2, c9_1, c29_2, c1_1, c_1, c9_3


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

(77) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace ENCARG(cons_app(x0, nil)) -> c9(APP(encArg(x0), nil), ENCARG(x0)) by 
   ENCARG(cons_app(fold, nil)) -> c9(APP(fold, nil), ENCARG(fold))
   ENCARG(cons_app(nil, nil)) -> c9(APP(nil, nil), ENCARG(nil))
   ENCARG(cons_app(cons, nil)) -> c9(APP(cons, nil), ENCARG(cons))
   ENCARG(cons_app(plus, nil)) -> c9(APP(plus, nil), ENCARG(plus))
   ENCARG(cons_app(0, nil)) -> c9(APP(0, nil), ENCARG(0))
   ENCARG(cons_app(s, nil)) -> c9(APP(s, nil), ENCARG(s))
   ENCARG(cons_app(times, nil)) -> c9(APP(times, nil), ENCARG(times))
   ENCARG(cons_app(add, nil)) -> c9(APP(add, nil), ENCARG(add))
   ENCARG(cons_app(mul, nil)) -> c9(APP(mul, nil), ENCARG(mul))
   ENCARG(cons_app(cons_app(z0, z1), nil)) -> c9(APP(app(encArg(z0), encArg(z1)), nil), ENCARG(cons_app(z0, z1)))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil), ENCARG(cons_prod))

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

(78)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, cons)) -> c9(APP(encArg(x0), cons), ENCARG(x0))
   ENCARG(cons_app(x0, plus)) -> c9(APP(encArg(x0), plus), ENCARG(x0))
   ENCARG(cons_app(x0, 0)) -> c9(APP(encArg(x0), 0), ENCARG(x0))
   ENCARG(cons_app(x0, s)) -> c9(APP(encArg(x0), s), ENCARG(x0))
   ENCARG(cons_app(x0, times)) -> c9(APP(encArg(x0), times), ENCARG(x0))
   ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(fold, nil)) -> c9(APP(fold, nil), ENCARG(fold))
   ENCARG(cons_app(nil, nil)) -> c9(APP(nil, nil), ENCARG(nil))
   ENCARG(cons_app(cons, nil)) -> c9(APP(cons, nil), ENCARG(cons))
   ENCARG(cons_app(plus, nil)) -> c9(APP(plus, nil), ENCARG(plus))
   ENCARG(cons_app(0, nil)) -> c9(APP(0, nil), ENCARG(0))
   ENCARG(cons_app(s, nil)) -> c9(APP(s, nil), ENCARG(s))
   ENCARG(cons_app(times, nil)) -> c9(APP(times, nil), ENCARG(times))
   ENCARG(cons_app(add, nil)) -> c9(APP(add, nil), ENCARG(add))
   ENCARG(cons_app(mul, nil)) -> c9(APP(mul, nil), ENCARG(mul))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil), ENCARG(cons_prod))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_2, c9_1, c29_2, c1_1, c_1, c9_3


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

(79) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 9 trailing nodes:
   ENCARG(cons_app(times, nil)) -> c9(APP(times, nil), ENCARG(times))
   ENCARG(cons_app(s, nil)) -> c9(APP(s, nil), ENCARG(s))
   ENCARG(cons_app(0, nil)) -> c9(APP(0, nil), ENCARG(0))
   ENCARG(cons_app(fold, nil)) -> c9(APP(fold, nil), ENCARG(fold))
   ENCARG(cons_app(mul, nil)) -> c9(APP(mul, nil), ENCARG(mul))
   ENCARG(cons_app(nil, nil)) -> c9(APP(nil, nil), ENCARG(nil))
   ENCARG(cons_app(add, nil)) -> c9(APP(add, nil), ENCARG(add))
   ENCARG(cons_app(plus, nil)) -> c9(APP(plus, nil), ENCARG(plus))
   ENCARG(cons_app(cons, nil)) -> c9(APP(cons, nil), ENCARG(cons))

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

(80)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, cons)) -> c9(APP(encArg(x0), cons), ENCARG(x0))
   ENCARG(cons_app(x0, plus)) -> c9(APP(encArg(x0), plus), ENCARG(x0))
   ENCARG(cons_app(x0, 0)) -> c9(APP(encArg(x0), 0), ENCARG(x0))
   ENCARG(cons_app(x0, s)) -> c9(APP(encArg(x0), s), ENCARG(x0))
   ENCARG(cons_app(x0, times)) -> c9(APP(encArg(x0), times), ENCARG(x0))
   ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil), ENCARG(cons_prod))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_2, c9_1, c29_2, c1_1, c_1, c9_3


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

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

(82)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, cons)) -> c9(APP(encArg(x0), cons), ENCARG(x0))
   ENCARG(cons_app(x0, plus)) -> c9(APP(encArg(x0), plus), ENCARG(x0))
   ENCARG(cons_app(x0, 0)) -> c9(APP(encArg(x0), 0), ENCARG(x0))
   ENCARG(cons_app(x0, s)) -> c9(APP(encArg(x0), s), ENCARG(x0))
   ENCARG(cons_app(x0, times)) -> c9(APP(encArg(x0), times), ENCARG(x0))
   ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_2, c9_1, c29_2, c1_1, c_1, c9_3


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

(83) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace ENCARG(cons_app(x0, cons)) -> c9(APP(encArg(x0), cons), ENCARG(x0)) by 
   ENCARG(cons_app(fold, cons)) -> c9(APP(fold, cons), ENCARG(fold))
   ENCARG(cons_app(nil, cons)) -> c9(APP(nil, cons), ENCARG(nil))
   ENCARG(cons_app(cons, cons)) -> c9(APP(cons, cons), ENCARG(cons))
   ENCARG(cons_app(plus, cons)) -> c9(APP(plus, cons), ENCARG(plus))
   ENCARG(cons_app(0, cons)) -> c9(APP(0, cons), ENCARG(0))
   ENCARG(cons_app(s, cons)) -> c9(APP(s, cons), ENCARG(s))
   ENCARG(cons_app(times, cons)) -> c9(APP(times, cons), ENCARG(times))
   ENCARG(cons_app(add, cons)) -> c9(APP(add, cons), ENCARG(add))
   ENCARG(cons_app(mul, cons)) -> c9(APP(mul, cons), ENCARG(mul))
   ENCARG(cons_app(cons_app(z0, z1), cons)) -> c9(APP(app(encArg(z0), encArg(z1)), cons), ENCARG(cons_app(z0, z1)))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons), ENCARG(cons_prod))

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

(84)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, plus)) -> c9(APP(encArg(x0), plus), ENCARG(x0))
   ENCARG(cons_app(x0, 0)) -> c9(APP(encArg(x0), 0), ENCARG(x0))
   ENCARG(cons_app(x0, s)) -> c9(APP(encArg(x0), s), ENCARG(x0))
   ENCARG(cons_app(x0, times)) -> c9(APP(encArg(x0), times), ENCARG(x0))
   ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(fold, cons)) -> c9(APP(fold, cons), ENCARG(fold))
   ENCARG(cons_app(nil, cons)) -> c9(APP(nil, cons), ENCARG(nil))
   ENCARG(cons_app(cons, cons)) -> c9(APP(cons, cons), ENCARG(cons))
   ENCARG(cons_app(plus, cons)) -> c9(APP(plus, cons), ENCARG(plus))
   ENCARG(cons_app(0, cons)) -> c9(APP(0, cons), ENCARG(0))
   ENCARG(cons_app(s, cons)) -> c9(APP(s, cons), ENCARG(s))
   ENCARG(cons_app(times, cons)) -> c9(APP(times, cons), ENCARG(times))
   ENCARG(cons_app(add, cons)) -> c9(APP(add, cons), ENCARG(add))
   ENCARG(cons_app(mul, cons)) -> c9(APP(mul, cons), ENCARG(mul))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons), ENCARG(cons_prod))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_2, c9_1, c29_2, c1_1, c_1, c9_3


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

(85) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 9 trailing nodes:
   ENCARG(cons_app(mul, cons)) -> c9(APP(mul, cons), ENCARG(mul))
   ENCARG(cons_app(cons, cons)) -> c9(APP(cons, cons), ENCARG(cons))
   ENCARG(cons_app(times, cons)) -> c9(APP(times, cons), ENCARG(times))
   ENCARG(cons_app(s, cons)) -> c9(APP(s, cons), ENCARG(s))
   ENCARG(cons_app(nil, cons)) -> c9(APP(nil, cons), ENCARG(nil))
   ENCARG(cons_app(add, cons)) -> c9(APP(add, cons), ENCARG(add))
   ENCARG(cons_app(plus, cons)) -> c9(APP(plus, cons), ENCARG(plus))
   ENCARG(cons_app(fold, cons)) -> c9(APP(fold, cons), ENCARG(fold))
   ENCARG(cons_app(0, cons)) -> c9(APP(0, cons), ENCARG(0))

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

(86)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, plus)) -> c9(APP(encArg(x0), plus), ENCARG(x0))
   ENCARG(cons_app(x0, 0)) -> c9(APP(encArg(x0), 0), ENCARG(x0))
   ENCARG(cons_app(x0, s)) -> c9(APP(encArg(x0), s), ENCARG(x0))
   ENCARG(cons_app(x0, times)) -> c9(APP(encArg(x0), times), ENCARG(x0))
   ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons), ENCARG(cons_prod))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_2, c9_1, c29_2, c1_1, c_1, c9_3


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

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

(88)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, plus)) -> c9(APP(encArg(x0), plus), ENCARG(x0))
   ENCARG(cons_app(x0, 0)) -> c9(APP(encArg(x0), 0), ENCARG(x0))
   ENCARG(cons_app(x0, s)) -> c9(APP(encArg(x0), s), ENCARG(x0))
   ENCARG(cons_app(x0, times)) -> c9(APP(encArg(x0), times), ENCARG(x0))
   ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_2, c9_1, c29_2, c1_1, c_1, c9_3


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

(89) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace ENCARG(cons_app(x0, plus)) -> c9(APP(encArg(x0), plus), ENCARG(x0)) by 
   ENCARG(cons_app(fold, plus)) -> c9(APP(fold, plus), ENCARG(fold))
   ENCARG(cons_app(nil, plus)) -> c9(APP(nil, plus), ENCARG(nil))
   ENCARG(cons_app(cons, plus)) -> c9(APP(cons, plus), ENCARG(cons))
   ENCARG(cons_app(plus, plus)) -> c9(APP(plus, plus), ENCARG(plus))
   ENCARG(cons_app(0, plus)) -> c9(APP(0, plus), ENCARG(0))
   ENCARG(cons_app(s, plus)) -> c9(APP(s, plus), ENCARG(s))
   ENCARG(cons_app(times, plus)) -> c9(APP(times, plus), ENCARG(times))
   ENCARG(cons_app(add, plus)) -> c9(APP(add, plus), ENCARG(add))
   ENCARG(cons_app(mul, plus)) -> c9(APP(mul, plus), ENCARG(mul))
   ENCARG(cons_app(cons_app(z0, z1), plus)) -> c9(APP(app(encArg(z0), encArg(z1)), plus), ENCARG(cons_app(z0, z1)))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus), ENCARG(cons_prod))

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

(90)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, 0)) -> c9(APP(encArg(x0), 0), ENCARG(x0))
   ENCARG(cons_app(x0, s)) -> c9(APP(encArg(x0), s), ENCARG(x0))
   ENCARG(cons_app(x0, times)) -> c9(APP(encArg(x0), times), ENCARG(x0))
   ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(fold, plus)) -> c9(APP(fold, plus), ENCARG(fold))
   ENCARG(cons_app(nil, plus)) -> c9(APP(nil, plus), ENCARG(nil))
   ENCARG(cons_app(cons, plus)) -> c9(APP(cons, plus), ENCARG(cons))
   ENCARG(cons_app(plus, plus)) -> c9(APP(plus, plus), ENCARG(plus))
   ENCARG(cons_app(0, plus)) -> c9(APP(0, plus), ENCARG(0))
   ENCARG(cons_app(s, plus)) -> c9(APP(s, plus), ENCARG(s))
   ENCARG(cons_app(times, plus)) -> c9(APP(times, plus), ENCARG(times))
   ENCARG(cons_app(add, plus)) -> c9(APP(add, plus), ENCARG(add))
   ENCARG(cons_app(mul, plus)) -> c9(APP(mul, plus), ENCARG(mul))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus), ENCARG(cons_prod))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_2, c9_1, c29_2, c1_1, c_1, c9_3


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

(91) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 9 trailing nodes:
   ENCARG(cons_app(times, plus)) -> c9(APP(times, plus), ENCARG(times))
   ENCARG(cons_app(0, plus)) -> c9(APP(0, plus), ENCARG(0))
   ENCARG(cons_app(fold, plus)) -> c9(APP(fold, plus), ENCARG(fold))
   ENCARG(cons_app(mul, plus)) -> c9(APP(mul, plus), ENCARG(mul))
   ENCARG(cons_app(add, plus)) -> c9(APP(add, plus), ENCARG(add))
   ENCARG(cons_app(plus, plus)) -> c9(APP(plus, plus), ENCARG(plus))
   ENCARG(cons_app(cons, plus)) -> c9(APP(cons, plus), ENCARG(cons))
   ENCARG(cons_app(nil, plus)) -> c9(APP(nil, plus), ENCARG(nil))
   ENCARG(cons_app(s, plus)) -> c9(APP(s, plus), ENCARG(s))

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

(92)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, 0)) -> c9(APP(encArg(x0), 0), ENCARG(x0))
   ENCARG(cons_app(x0, s)) -> c9(APP(encArg(x0), s), ENCARG(x0))
   ENCARG(cons_app(x0, times)) -> c9(APP(encArg(x0), times), ENCARG(x0))
   ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus), ENCARG(cons_prod))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_2, c9_1, c29_2, c1_1, c_1, c9_3


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

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

(94)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, 0)) -> c9(APP(encArg(x0), 0), ENCARG(x0))
   ENCARG(cons_app(x0, s)) -> c9(APP(encArg(x0), s), ENCARG(x0))
   ENCARG(cons_app(x0, times)) -> c9(APP(encArg(x0), times), ENCARG(x0))
   ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_2, c9_1, c29_2, c1_1, c_1, c9_3


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

(95) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace ENCARG(cons_app(x0, 0)) -> c9(APP(encArg(x0), 0), ENCARG(x0)) by 
   ENCARG(cons_app(fold, 0)) -> c9(APP(fold, 0), ENCARG(fold))
   ENCARG(cons_app(nil, 0)) -> c9(APP(nil, 0), ENCARG(nil))
   ENCARG(cons_app(cons, 0)) -> c9(APP(cons, 0), ENCARG(cons))
   ENCARG(cons_app(plus, 0)) -> c9(APP(plus, 0), ENCARG(plus))
   ENCARG(cons_app(0, 0)) -> c9(APP(0, 0), ENCARG(0))
   ENCARG(cons_app(s, 0)) -> c9(APP(s, 0), ENCARG(s))
   ENCARG(cons_app(times, 0)) -> c9(APP(times, 0), ENCARG(times))
   ENCARG(cons_app(add, 0)) -> c9(APP(add, 0), ENCARG(add))
   ENCARG(cons_app(mul, 0)) -> c9(APP(mul, 0), ENCARG(mul))
   ENCARG(cons_app(cons_app(z0, z1), 0)) -> c9(APP(app(encArg(z0), encArg(z1)), 0), ENCARG(cons_app(z0, z1)))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0), ENCARG(cons_prod))

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

(96)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, s)) -> c9(APP(encArg(x0), s), ENCARG(x0))
   ENCARG(cons_app(x0, times)) -> c9(APP(encArg(x0), times), ENCARG(x0))
   ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(fold, 0)) -> c9(APP(fold, 0), ENCARG(fold))
   ENCARG(cons_app(nil, 0)) -> c9(APP(nil, 0), ENCARG(nil))
   ENCARG(cons_app(cons, 0)) -> c9(APP(cons, 0), ENCARG(cons))
   ENCARG(cons_app(plus, 0)) -> c9(APP(plus, 0), ENCARG(plus))
   ENCARG(cons_app(0, 0)) -> c9(APP(0, 0), ENCARG(0))
   ENCARG(cons_app(s, 0)) -> c9(APP(s, 0), ENCARG(s))
   ENCARG(cons_app(times, 0)) -> c9(APP(times, 0), ENCARG(times))
   ENCARG(cons_app(add, 0)) -> c9(APP(add, 0), ENCARG(add))
   ENCARG(cons_app(mul, 0)) -> c9(APP(mul, 0), ENCARG(mul))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0), ENCARG(cons_prod))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_2, c9_1, c29_2, c1_1, c_1, c9_3


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

(97) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 9 trailing nodes:
   ENCARG(cons_app(0, 0)) -> c9(APP(0, 0), ENCARG(0))
   ENCARG(cons_app(add, 0)) -> c9(APP(add, 0), ENCARG(add))
   ENCARG(cons_app(plus, 0)) -> c9(APP(plus, 0), ENCARG(plus))
   ENCARG(cons_app(times, 0)) -> c9(APP(times, 0), ENCARG(times))
   ENCARG(cons_app(fold, 0)) -> c9(APP(fold, 0), ENCARG(fold))
   ENCARG(cons_app(nil, 0)) -> c9(APP(nil, 0), ENCARG(nil))
   ENCARG(cons_app(s, 0)) -> c9(APP(s, 0), ENCARG(s))
   ENCARG(cons_app(mul, 0)) -> c9(APP(mul, 0), ENCARG(mul))
   ENCARG(cons_app(cons, 0)) -> c9(APP(cons, 0), ENCARG(cons))

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

(98)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, s)) -> c9(APP(encArg(x0), s), ENCARG(x0))
   ENCARG(cons_app(x0, times)) -> c9(APP(encArg(x0), times), ENCARG(x0))
   ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0), ENCARG(cons_prod))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_2, c9_1, c29_2, c1_1, c_1, c9_3


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

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

(100)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, s)) -> c9(APP(encArg(x0), s), ENCARG(x0))
   ENCARG(cons_app(x0, times)) -> c9(APP(encArg(x0), times), ENCARG(x0))
   ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_2, c9_1, c29_2, c1_1, c_1, c9_3


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

(101) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace ENCARG(cons_app(x0, s)) -> c9(APP(encArg(x0), s), ENCARG(x0)) by 
   ENCARG(cons_app(fold, s)) -> c9(APP(fold, s), ENCARG(fold))
   ENCARG(cons_app(nil, s)) -> c9(APP(nil, s), ENCARG(nil))
   ENCARG(cons_app(cons, s)) -> c9(APP(cons, s), ENCARG(cons))
   ENCARG(cons_app(plus, s)) -> c9(APP(plus, s), ENCARG(plus))
   ENCARG(cons_app(0, s)) -> c9(APP(0, s), ENCARG(0))
   ENCARG(cons_app(s, s)) -> c9(APP(s, s), ENCARG(s))
   ENCARG(cons_app(times, s)) -> c9(APP(times, s), ENCARG(times))
   ENCARG(cons_app(add, s)) -> c9(APP(add, s), ENCARG(add))
   ENCARG(cons_app(mul, s)) -> c9(APP(mul, s), ENCARG(mul))
   ENCARG(cons_app(cons_app(z0, z1), s)) -> c9(APP(app(encArg(z0), encArg(z1)), s), ENCARG(cons_app(z0, z1)))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s), ENCARG(cons_prod))

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

(102)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, times)) -> c9(APP(encArg(x0), times), ENCARG(x0))
   ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0))
   ENCARG(cons_app(fold, s)) -> c9(APP(fold, s), ENCARG(fold))
   ENCARG(cons_app(nil, s)) -> c9(APP(nil, s), ENCARG(nil))
   ENCARG(cons_app(cons, s)) -> c9(APP(cons, s), ENCARG(cons))
   ENCARG(cons_app(plus, s)) -> c9(APP(plus, s), ENCARG(plus))
   ENCARG(cons_app(0, s)) -> c9(APP(0, s), ENCARG(0))
   ENCARG(cons_app(s, s)) -> c9(APP(s, s), ENCARG(s))
   ENCARG(cons_app(times, s)) -> c9(APP(times, s), ENCARG(times))
   ENCARG(cons_app(add, s)) -> c9(APP(add, s), ENCARG(add))
   ENCARG(cons_app(mul, s)) -> c9(APP(mul, s), ENCARG(mul))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s), ENCARG(cons_prod))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_2, c9_1, c29_2, c1_1, c_1, c9_3


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

(103) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 9 trailing nodes:
   ENCARG(cons_app(fold, s)) -> c9(APP(fold, s), ENCARG(fold))
   ENCARG(cons_app(mul, s)) -> c9(APP(mul, s), ENCARG(mul))
   ENCARG(cons_app(s, s)) -> c9(APP(s, s), ENCARG(s))
   ENCARG(cons_app(add, s)) -> c9(APP(add, s), ENCARG(add))
   ENCARG(cons_app(times, s)) -> c9(APP(times, s), ENCARG(times))
   ENCARG(cons_app(plus, s)) -> c9(APP(plus, s), ENCARG(plus))
   ENCARG(cons_app(cons, s)) -> c9(APP(cons, s), ENCARG(cons))
   ENCARG(cons_app(0, s)) -> c9(APP(0, s), ENCARG(0))
   ENCARG(cons_app(nil, s)) -> c9(APP(nil, s), ENCARG(nil))

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

(104)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, times)) -> c9(APP(encArg(x0), times), ENCARG(x0))
   ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s), ENCARG(cons_prod))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_2, c9_1, c29_2, c1_1, c_1, c9_3


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

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

(106)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, times)) -> c9(APP(encArg(x0), times), ENCARG(x0))
   ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_2, c9_1, c29_2, c1_1, c_1, c9_3


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

(107) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace ENCARG(cons_app(x0, times)) -> c9(APP(encArg(x0), times), ENCARG(x0)) by 
   ENCARG(cons_app(fold, times)) -> c9(APP(fold, times), ENCARG(fold))
   ENCARG(cons_app(nil, times)) -> c9(APP(nil, times), ENCARG(nil))
   ENCARG(cons_app(cons, times)) -> c9(APP(cons, times), ENCARG(cons))
   ENCARG(cons_app(plus, times)) -> c9(APP(plus, times), ENCARG(plus))
   ENCARG(cons_app(0, times)) -> c9(APP(0, times), ENCARG(0))
   ENCARG(cons_app(s, times)) -> c9(APP(s, times), ENCARG(s))
   ENCARG(cons_app(times, times)) -> c9(APP(times, times), ENCARG(times))
   ENCARG(cons_app(add, times)) -> c9(APP(add, times), ENCARG(add))
   ENCARG(cons_app(mul, times)) -> c9(APP(mul, times), ENCARG(mul))
   ENCARG(cons_app(cons_app(z0, z1), times)) -> c9(APP(app(encArg(z0), encArg(z1)), times), ENCARG(cons_app(z0, z1)))
   ENCARG(cons_app(cons_sum, times)) -> c9(APP(sum, times), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, times)) -> c9(APP(prod, times), ENCARG(cons_prod))

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

(108)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s))
   ENCARG(cons_app(fold, times)) -> c9(APP(fold, times), ENCARG(fold))
   ENCARG(cons_app(nil, times)) -> c9(APP(nil, times), ENCARG(nil))
   ENCARG(cons_app(cons, times)) -> c9(APP(cons, times), ENCARG(cons))
   ENCARG(cons_app(plus, times)) -> c9(APP(plus, times), ENCARG(plus))
   ENCARG(cons_app(0, times)) -> c9(APP(0, times), ENCARG(0))
   ENCARG(cons_app(s, times)) -> c9(APP(s, times), ENCARG(s))
   ENCARG(cons_app(times, times)) -> c9(APP(times, times), ENCARG(times))
   ENCARG(cons_app(add, times)) -> c9(APP(add, times), ENCARG(add))
   ENCARG(cons_app(mul, times)) -> c9(APP(mul, times), ENCARG(mul))
   ENCARG(cons_app(cons_sum, times)) -> c9(APP(sum, times), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, times)) -> c9(APP(prod, times), ENCARG(cons_prod))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_2, c9_1, c29_2, c1_1, c_1, c9_3


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

(109) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 9 trailing nodes:
   ENCARG(cons_app(0, times)) -> c9(APP(0, times), ENCARG(0))
   ENCARG(cons_app(nil, times)) -> c9(APP(nil, times), ENCARG(nil))
   ENCARG(cons_app(add, times)) -> c9(APP(add, times), ENCARG(add))
   ENCARG(cons_app(times, times)) -> c9(APP(times, times), ENCARG(times))
   ENCARG(cons_app(plus, times)) -> c9(APP(plus, times), ENCARG(plus))
   ENCARG(cons_app(mul, times)) -> c9(APP(mul, times), ENCARG(mul))
   ENCARG(cons_app(fold, times)) -> c9(APP(fold, times), ENCARG(fold))
   ENCARG(cons_app(cons, times)) -> c9(APP(cons, times), ENCARG(cons))
   ENCARG(cons_app(s, times)) -> c9(APP(s, times), ENCARG(s))

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

(110)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s))
   ENCARG(cons_app(cons_sum, times)) -> c9(APP(sum, times), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, times)) -> c9(APP(prod, times), ENCARG(cons_prod))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_2, c9_1, c29_2, c1_1, c_1, c9_3


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

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

(112)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s))
   ENCARG(cons_app(cons_sum, times)) -> c9(APP(sum, times))
   ENCARG(cons_app(cons_prod, times)) -> c9(APP(prod, times))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_2, c9_1, c29_2, c1_1, c_1, c9_3


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

(113) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace ENCARG(cons_app(x0, add)) -> c9(APP(encArg(x0), add), ENCARG(x0)) by 
   ENCARG(cons_app(fold, add)) -> c9(APP(fold, add), ENCARG(fold))
   ENCARG(cons_app(nil, add)) -> c9(APP(nil, add), ENCARG(nil))
   ENCARG(cons_app(cons, add)) -> c9(APP(cons, add), ENCARG(cons))
   ENCARG(cons_app(plus, add)) -> c9(APP(plus, add), ENCARG(plus))
   ENCARG(cons_app(0, add)) -> c9(APP(0, add), ENCARG(0))
   ENCARG(cons_app(s, add)) -> c9(APP(s, add), ENCARG(s))
   ENCARG(cons_app(times, add)) -> c9(APP(times, add), ENCARG(times))
   ENCARG(cons_app(add, add)) -> c9(APP(add, add), ENCARG(add))
   ENCARG(cons_app(mul, add)) -> c9(APP(mul, add), ENCARG(mul))
   ENCARG(cons_app(cons_app(z0, z1), add)) -> c9(APP(app(encArg(z0), encArg(z1)), add), ENCARG(cons_app(z0, z1)))
   ENCARG(cons_app(cons_sum, add)) -> c9(APP(sum, add), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, add)) -> c9(APP(prod, add), ENCARG(cons_prod))

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

(114)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s))
   ENCARG(cons_app(cons_sum, times)) -> c9(APP(sum, times))
   ENCARG(cons_app(cons_prod, times)) -> c9(APP(prod, times))
   ENCARG(cons_app(fold, add)) -> c9(APP(fold, add), ENCARG(fold))
   ENCARG(cons_app(nil, add)) -> c9(APP(nil, add), ENCARG(nil))
   ENCARG(cons_app(cons, add)) -> c9(APP(cons, add), ENCARG(cons))
   ENCARG(cons_app(plus, add)) -> c9(APP(plus, add), ENCARG(plus))
   ENCARG(cons_app(0, add)) -> c9(APP(0, add), ENCARG(0))
   ENCARG(cons_app(s, add)) -> c9(APP(s, add), ENCARG(s))
   ENCARG(cons_app(times, add)) -> c9(APP(times, add), ENCARG(times))
   ENCARG(cons_app(add, add)) -> c9(APP(add, add), ENCARG(add))
   ENCARG(cons_app(mul, add)) -> c9(APP(mul, add), ENCARG(mul))
   ENCARG(cons_app(cons_sum, add)) -> c9(APP(sum, add), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, add)) -> c9(APP(prod, add), ENCARG(cons_prod))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_2, c9_1, c29_2, c1_1, c_1, c9_3


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

(115) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 9 trailing nodes:
   ENCARG(cons_app(mul, add)) -> c9(APP(mul, add), ENCARG(mul))
   ENCARG(cons_app(add, add)) -> c9(APP(add, add), ENCARG(add))
   ENCARG(cons_app(plus, add)) -> c9(APP(plus, add), ENCARG(plus))
   ENCARG(cons_app(cons, add)) -> c9(APP(cons, add), ENCARG(cons))
   ENCARG(cons_app(nil, add)) -> c9(APP(nil, add), ENCARG(nil))
   ENCARG(cons_app(s, add)) -> c9(APP(s, add), ENCARG(s))
   ENCARG(cons_app(fold, add)) -> c9(APP(fold, add), ENCARG(fold))
   ENCARG(cons_app(times, add)) -> c9(APP(times, add), ENCARG(times))
   ENCARG(cons_app(0, add)) -> c9(APP(0, add), ENCARG(0))

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

(116)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s))
   ENCARG(cons_app(cons_sum, times)) -> c9(APP(sum, times))
   ENCARG(cons_app(cons_prod, times)) -> c9(APP(prod, times))
   ENCARG(cons_app(cons_sum, add)) -> c9(APP(sum, add), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, add)) -> c9(APP(prod, add), ENCARG(cons_prod))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_2, c9_1, c29_2, c1_1, c_1, c9_3


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

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

(118)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s))
   ENCARG(cons_app(cons_sum, times)) -> c9(APP(sum, times))
   ENCARG(cons_app(cons_prod, times)) -> c9(APP(prod, times))
   ENCARG(cons_app(cons_sum, add)) -> c9(APP(sum, add))
   ENCARG(cons_app(cons_prod, add)) -> c9(APP(prod, add))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_2, c9_1, c29_2, c1_1, c_1, c9_3


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

(119) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace ENCARG(cons_app(x0, mul)) -> c9(APP(encArg(x0), mul), ENCARG(x0)) by 
   ENCARG(cons_app(fold, mul)) -> c9(APP(fold, mul), ENCARG(fold))
   ENCARG(cons_app(nil, mul)) -> c9(APP(nil, mul), ENCARG(nil))
   ENCARG(cons_app(cons, mul)) -> c9(APP(cons, mul), ENCARG(cons))
   ENCARG(cons_app(plus, mul)) -> c9(APP(plus, mul), ENCARG(plus))
   ENCARG(cons_app(0, mul)) -> c9(APP(0, mul), ENCARG(0))
   ENCARG(cons_app(s, mul)) -> c9(APP(s, mul), ENCARG(s))
   ENCARG(cons_app(times, mul)) -> c9(APP(times, mul), ENCARG(times))
   ENCARG(cons_app(add, mul)) -> c9(APP(add, mul), ENCARG(add))
   ENCARG(cons_app(mul, mul)) -> c9(APP(mul, mul), ENCARG(mul))
   ENCARG(cons_app(cons_app(z0, z1), mul)) -> c9(APP(app(encArg(z0), encArg(z1)), mul), ENCARG(cons_app(z0, z1)))
   ENCARG(cons_app(cons_sum, mul)) -> c9(APP(sum, mul), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, mul)) -> c9(APP(prod, mul), ENCARG(cons_prod))

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

(120)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s))
   ENCARG(cons_app(cons_sum, times)) -> c9(APP(sum, times))
   ENCARG(cons_app(cons_prod, times)) -> c9(APP(prod, times))
   ENCARG(cons_app(cons_sum, add)) -> c9(APP(sum, add))
   ENCARG(cons_app(cons_prod, add)) -> c9(APP(prod, add))
   ENCARG(cons_app(fold, mul)) -> c9(APP(fold, mul), ENCARG(fold))
   ENCARG(cons_app(nil, mul)) -> c9(APP(nil, mul), ENCARG(nil))
   ENCARG(cons_app(cons, mul)) -> c9(APP(cons, mul), ENCARG(cons))
   ENCARG(cons_app(plus, mul)) -> c9(APP(plus, mul), ENCARG(plus))
   ENCARG(cons_app(0, mul)) -> c9(APP(0, mul), ENCARG(0))
   ENCARG(cons_app(s, mul)) -> c9(APP(s, mul), ENCARG(s))
   ENCARG(cons_app(times, mul)) -> c9(APP(times, mul), ENCARG(times))
   ENCARG(cons_app(add, mul)) -> c9(APP(add, mul), ENCARG(add))
   ENCARG(cons_app(mul, mul)) -> c9(APP(mul, mul), ENCARG(mul))
   ENCARG(cons_app(cons_sum, mul)) -> c9(APP(sum, mul), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, mul)) -> c9(APP(prod, mul), ENCARG(cons_prod))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_2, c9_1, c29_2, c1_1, c_1, c9_3


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

(121) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 9 trailing nodes:
   ENCARG(cons_app(times, mul)) -> c9(APP(times, mul), ENCARG(times))
   ENCARG(cons_app(fold, mul)) -> c9(APP(fold, mul), ENCARG(fold))
   ENCARG(cons_app(mul, mul)) -> c9(APP(mul, mul), ENCARG(mul))
   ENCARG(cons_app(add, mul)) -> c9(APP(add, mul), ENCARG(add))
   ENCARG(cons_app(plus, mul)) -> c9(APP(plus, mul), ENCARG(plus))
   ENCARG(cons_app(s, mul)) -> c9(APP(s, mul), ENCARG(s))
   ENCARG(cons_app(0, mul)) -> c9(APP(0, mul), ENCARG(0))
   ENCARG(cons_app(cons, mul)) -> c9(APP(cons, mul), ENCARG(cons))
   ENCARG(cons_app(nil, mul)) -> c9(APP(nil, mul), ENCARG(nil))

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

(122)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s))
   ENCARG(cons_app(cons_sum, times)) -> c9(APP(sum, times))
   ENCARG(cons_app(cons_prod, times)) -> c9(APP(prod, times))
   ENCARG(cons_app(cons_sum, add)) -> c9(APP(sum, add))
   ENCARG(cons_app(cons_prod, add)) -> c9(APP(prod, add))
   ENCARG(cons_app(cons_sum, mul)) -> c9(APP(sum, mul), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, mul)) -> c9(APP(prod, mul), ENCARG(cons_prod))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_2, c9_1, c29_2, c1_1, c_1, c9_3


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

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

(124)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s))
   ENCARG(cons_app(cons_sum, times)) -> c9(APP(sum, times))
   ENCARG(cons_app(cons_prod, times)) -> c9(APP(prod, times))
   ENCARG(cons_app(cons_sum, add)) -> c9(APP(sum, add))
   ENCARG(cons_app(cons_prod, add)) -> c9(APP(prod, add))
   ENCARG(cons_app(cons_sum, mul)) -> c9(APP(sum, mul))
   ENCARG(cons_app(cons_prod, mul)) -> c9(APP(prod, mul))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_2, c9_1, c29_2, c1_1, c_1, c9_3


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

(125) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), sum), ENCARG(x0)) by 
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), app(app(fold, add), 0)), ENCARG(x0))
   ENCARG(cons_app(fold, cons_sum)) -> c9(APP(fold, sum), ENCARG(fold))
   ENCARG(cons_app(nil, cons_sum)) -> c9(APP(nil, sum), ENCARG(nil))
   ENCARG(cons_app(cons, cons_sum)) -> c9(APP(cons, sum), ENCARG(cons))
   ENCARG(cons_app(plus, cons_sum)) -> c9(APP(plus, sum), ENCARG(plus))
   ENCARG(cons_app(0, cons_sum)) -> c9(APP(0, sum), ENCARG(0))
   ENCARG(cons_app(s, cons_sum)) -> c9(APP(s, sum), ENCARG(s))
   ENCARG(cons_app(times, cons_sum)) -> c9(APP(times, sum), ENCARG(times))
   ENCARG(cons_app(add, cons_sum)) -> c9(APP(add, sum), ENCARG(add))
   ENCARG(cons_app(mul, cons_sum)) -> c9(APP(mul, sum), ENCARG(mul))
   ENCARG(cons_app(cons_app(z0, z1), cons_sum)) -> c9(APP(app(encArg(z0), encArg(z1)), sum), ENCARG(cons_app(z0, z1)))
   ENCARG(cons_app(cons_sum, cons_sum)) -> c9(APP(sum, sum), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, cons_sum)) -> c9(APP(prod, sum), ENCARG(cons_prod))

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

(126)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s))
   ENCARG(cons_app(cons_sum, times)) -> c9(APP(sum, times))
   ENCARG(cons_app(cons_prod, times)) -> c9(APP(prod, times))
   ENCARG(cons_app(cons_sum, add)) -> c9(APP(sum, add))
   ENCARG(cons_app(cons_prod, add)) -> c9(APP(prod, add))
   ENCARG(cons_app(cons_sum, mul)) -> c9(APP(sum, mul))
   ENCARG(cons_app(cons_prod, mul)) -> c9(APP(prod, mul))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), app(app(fold, add), 0)), ENCARG(x0))
   ENCARG(cons_app(fold, cons_sum)) -> c9(APP(fold, sum), ENCARG(fold))
   ENCARG(cons_app(nil, cons_sum)) -> c9(APP(nil, sum), ENCARG(nil))
   ENCARG(cons_app(cons, cons_sum)) -> c9(APP(cons, sum), ENCARG(cons))
   ENCARG(cons_app(plus, cons_sum)) -> c9(APP(plus, sum), ENCARG(plus))
   ENCARG(cons_app(0, cons_sum)) -> c9(APP(0, sum), ENCARG(0))
   ENCARG(cons_app(s, cons_sum)) -> c9(APP(s, sum), ENCARG(s))
   ENCARG(cons_app(times, cons_sum)) -> c9(APP(times, sum), ENCARG(times))
   ENCARG(cons_app(add, cons_sum)) -> c9(APP(add, sum), ENCARG(add))
   ENCARG(cons_app(mul, cons_sum)) -> c9(APP(mul, sum), ENCARG(mul))
   ENCARG(cons_app(cons_sum, cons_sum)) -> c9(APP(sum, sum), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, cons_sum)) -> c9(APP(prod, sum), ENCARG(cons_prod))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_2, c9_1, c29_2, c1_1, c_1, c9_3


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

(127) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 9 trailing nodes:
   ENCARG(cons_app(0, cons_sum)) -> c9(APP(0, sum), ENCARG(0))
   ENCARG(cons_app(plus, cons_sum)) -> c9(APP(plus, sum), ENCARG(plus))
   ENCARG(cons_app(add, cons_sum)) -> c9(APP(add, sum), ENCARG(add))
   ENCARG(cons_app(nil, cons_sum)) -> c9(APP(nil, sum), ENCARG(nil))
   ENCARG(cons_app(times, cons_sum)) -> c9(APP(times, sum), ENCARG(times))
   ENCARG(cons_app(s, cons_sum)) -> c9(APP(s, sum), ENCARG(s))
   ENCARG(cons_app(cons, cons_sum)) -> c9(APP(cons, sum), ENCARG(cons))
   ENCARG(cons_app(mul, cons_sum)) -> c9(APP(mul, sum), ENCARG(mul))
   ENCARG(cons_app(fold, cons_sum)) -> c9(APP(fold, sum), ENCARG(fold))

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

(128)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s))
   ENCARG(cons_app(cons_sum, times)) -> c9(APP(sum, times))
   ENCARG(cons_app(cons_prod, times)) -> c9(APP(prod, times))
   ENCARG(cons_app(cons_sum, add)) -> c9(APP(sum, add))
   ENCARG(cons_app(cons_prod, add)) -> c9(APP(prod, add))
   ENCARG(cons_app(cons_sum, mul)) -> c9(APP(sum, mul))
   ENCARG(cons_app(cons_prod, mul)) -> c9(APP(prod, mul))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), app(app(fold, add), 0)), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_sum)) -> c9(APP(sum, sum), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, cons_sum)) -> c9(APP(prod, sum), ENCARG(cons_prod))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_2, c9_1, c29_2, c1_1, c_1, c9_3


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

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

(130)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s))
   ENCARG(cons_app(cons_sum, times)) -> c9(APP(sum, times))
   ENCARG(cons_app(cons_prod, times)) -> c9(APP(prod, times))
   ENCARG(cons_app(cons_sum, add)) -> c9(APP(sum, add))
   ENCARG(cons_app(cons_prod, add)) -> c9(APP(prod, add))
   ENCARG(cons_app(cons_sum, mul)) -> c9(APP(sum, mul))
   ENCARG(cons_app(cons_prod, mul)) -> c9(APP(prod, mul))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), app(app(fold, add), 0)), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_sum)) -> c9(APP(sum, sum))
   ENCARG(cons_app(cons_prod, cons_sum)) -> c9(APP(prod, sum))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_2, c9_1, c29_2, c1_1, c_1, c9_3


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

(131) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), prod), ENCARG(x0)) by 
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), app(app(fold, mul), app(s, 0))), ENCARG(x0))
   ENCARG(cons_app(fold, cons_prod)) -> c9(APP(fold, prod), ENCARG(fold))
   ENCARG(cons_app(nil, cons_prod)) -> c9(APP(nil, prod), ENCARG(nil))
   ENCARG(cons_app(cons, cons_prod)) -> c9(APP(cons, prod), ENCARG(cons))
   ENCARG(cons_app(plus, cons_prod)) -> c9(APP(plus, prod), ENCARG(plus))
   ENCARG(cons_app(0, cons_prod)) -> c9(APP(0, prod), ENCARG(0))
   ENCARG(cons_app(s, cons_prod)) -> c9(APP(s, prod), ENCARG(s))
   ENCARG(cons_app(times, cons_prod)) -> c9(APP(times, prod), ENCARG(times))
   ENCARG(cons_app(add, cons_prod)) -> c9(APP(add, prod), ENCARG(add))
   ENCARG(cons_app(mul, cons_prod)) -> c9(APP(mul, prod), ENCARG(mul))
   ENCARG(cons_app(cons_app(z0, z1), cons_prod)) -> c9(APP(app(encArg(z0), encArg(z1)), prod), ENCARG(cons_app(z0, z1)))
   ENCARG(cons_app(cons_sum, cons_prod)) -> c9(APP(sum, prod), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, cons_prod)) -> c9(APP(prod, prod), ENCARG(cons_prod))

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

(132)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s))
   ENCARG(cons_app(cons_sum, times)) -> c9(APP(sum, times))
   ENCARG(cons_app(cons_prod, times)) -> c9(APP(prod, times))
   ENCARG(cons_app(cons_sum, add)) -> c9(APP(sum, add))
   ENCARG(cons_app(cons_prod, add)) -> c9(APP(prod, add))
   ENCARG(cons_app(cons_sum, mul)) -> c9(APP(sum, mul))
   ENCARG(cons_app(cons_prod, mul)) -> c9(APP(prod, mul))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), app(app(fold, add), 0)), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_sum)) -> c9(APP(sum, sum))
   ENCARG(cons_app(cons_prod, cons_sum)) -> c9(APP(prod, sum))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), app(app(fold, mul), app(s, 0))), ENCARG(x0))
   ENCARG(cons_app(fold, cons_prod)) -> c9(APP(fold, prod), ENCARG(fold))
   ENCARG(cons_app(nil, cons_prod)) -> c9(APP(nil, prod), ENCARG(nil))
   ENCARG(cons_app(cons, cons_prod)) -> c9(APP(cons, prod), ENCARG(cons))
   ENCARG(cons_app(plus, cons_prod)) -> c9(APP(plus, prod), ENCARG(plus))
   ENCARG(cons_app(0, cons_prod)) -> c9(APP(0, prod), ENCARG(0))
   ENCARG(cons_app(s, cons_prod)) -> c9(APP(s, prod), ENCARG(s))
   ENCARG(cons_app(times, cons_prod)) -> c9(APP(times, prod), ENCARG(times))
   ENCARG(cons_app(add, cons_prod)) -> c9(APP(add, prod), ENCARG(add))
   ENCARG(cons_app(mul, cons_prod)) -> c9(APP(mul, prod), ENCARG(mul))
   ENCARG(cons_app(cons_sum, cons_prod)) -> c9(APP(sum, prod), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, cons_prod)) -> c9(APP(prod, prod), ENCARG(cons_prod))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_1, c9_2, c29_2, c1_1, c_1, c9_3


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

(133) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 9 trailing nodes:
   ENCARG(cons_app(add, cons_prod)) -> c9(APP(add, prod), ENCARG(add))
   ENCARG(cons_app(s, cons_prod)) -> c9(APP(s, prod), ENCARG(s))
   ENCARG(cons_app(times, cons_prod)) -> c9(APP(times, prod), ENCARG(times))
   ENCARG(cons_app(cons, cons_prod)) -> c9(APP(cons, prod), ENCARG(cons))
   ENCARG(cons_app(nil, cons_prod)) -> c9(APP(nil, prod), ENCARG(nil))
   ENCARG(cons_app(plus, cons_prod)) -> c9(APP(plus, prod), ENCARG(plus))
   ENCARG(cons_app(fold, cons_prod)) -> c9(APP(fold, prod), ENCARG(fold))
   ENCARG(cons_app(mul, cons_prod)) -> c9(APP(mul, prod), ENCARG(mul))
   ENCARG(cons_app(0, cons_prod)) -> c9(APP(0, prod), ENCARG(0))

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

(134)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s))
   ENCARG(cons_app(cons_sum, times)) -> c9(APP(sum, times))
   ENCARG(cons_app(cons_prod, times)) -> c9(APP(prod, times))
   ENCARG(cons_app(cons_sum, add)) -> c9(APP(sum, add))
   ENCARG(cons_app(cons_prod, add)) -> c9(APP(prod, add))
   ENCARG(cons_app(cons_sum, mul)) -> c9(APP(sum, mul))
   ENCARG(cons_app(cons_prod, mul)) -> c9(APP(prod, mul))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), app(app(fold, add), 0)), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_sum)) -> c9(APP(sum, sum))
   ENCARG(cons_app(cons_prod, cons_sum)) -> c9(APP(prod, sum))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), app(app(fold, mul), app(s, 0))), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_prod)) -> c9(APP(sum, prod), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, cons_prod)) -> c9(APP(prod, prod), ENCARG(cons_prod))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_1, c9_2, c29_2, c1_1, c_1, c9_3


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

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

(136)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s))
   ENCARG(cons_app(cons_sum, times)) -> c9(APP(sum, times))
   ENCARG(cons_app(cons_prod, times)) -> c9(APP(prod, times))
   ENCARG(cons_app(cons_sum, add)) -> c9(APP(sum, add))
   ENCARG(cons_app(cons_prod, add)) -> c9(APP(prod, add))
   ENCARG(cons_app(cons_sum, mul)) -> c9(APP(sum, mul))
   ENCARG(cons_app(cons_prod, mul)) -> c9(APP(prod, mul))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), app(app(fold, add), 0)), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_sum)) -> c9(APP(sum, sum))
   ENCARG(cons_app(cons_prod, cons_sum)) -> c9(APP(prod, sum))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), app(app(fold, mul), app(s, 0))), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_prod)) -> c9(APP(sum, prod))
   ENCARG(cons_app(cons_prod, cons_prod)) -> c9(APP(prod, prod))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_1, c9_2, c29_2, c1_1, c_1, c9_3


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

(137) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace ENCARG(cons_app(cons_sum, x1)) -> c9(APP(sum, encArg(x1)), ENCARG(x1)) by 
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold), ENCARG(fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil), ENCARG(nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons), ENCARG(cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus), ENCARG(plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0), ENCARG(0))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s), ENCARG(s))
   ENCARG(cons_app(cons_sum, times)) -> c9(APP(sum, times), ENCARG(times))
   ENCARG(cons_app(cons_sum, add)) -> c9(APP(sum, add), ENCARG(add))
   ENCARG(cons_app(cons_sum, mul)) -> c9(APP(sum, mul), ENCARG(mul))
   ENCARG(cons_app(cons_sum, cons_app(z0, z1))) -> c9(APP(sum, app(encArg(z0), encArg(z1))), ENCARG(cons_app(z0, z1)))
   ENCARG(cons_app(cons_sum, cons_sum)) -> c9(APP(sum, sum), ENCARG(cons_sum))
   ENCARG(cons_app(cons_sum, cons_prod)) -> c9(APP(sum, prod), ENCARG(cons_prod))
   ENCARG(cons_app(cons_sum, x0)) -> c9(APP(app(app(fold, add), 0), encArg(x0)), ENCARG(x0))

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

(138)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s))
   ENCARG(cons_app(cons_sum, times)) -> c9(APP(sum, times))
   ENCARG(cons_app(cons_prod, times)) -> c9(APP(prod, times))
   ENCARG(cons_app(cons_sum, add)) -> c9(APP(sum, add))
   ENCARG(cons_app(cons_prod, add)) -> c9(APP(prod, add))
   ENCARG(cons_app(cons_sum, mul)) -> c9(APP(sum, mul))
   ENCARG(cons_app(cons_prod, mul)) -> c9(APP(prod, mul))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), app(app(fold, add), 0)), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_sum)) -> c9(APP(sum, sum))
   ENCARG(cons_app(cons_prod, cons_sum)) -> c9(APP(prod, sum))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), app(app(fold, mul), app(s, 0))), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_prod)) -> c9(APP(sum, prod))
   ENCARG(cons_app(cons_prod, cons_prod)) -> c9(APP(prod, prod))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold), ENCARG(fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil), ENCARG(nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons), ENCARG(cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus), ENCARG(plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0), ENCARG(0))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s), ENCARG(s))
   ENCARG(cons_app(cons_sum, times)) -> c9(APP(sum, times), ENCARG(times))
   ENCARG(cons_app(cons_sum, add)) -> c9(APP(sum, add), ENCARG(add))
   ENCARG(cons_app(cons_sum, mul)) -> c9(APP(sum, mul), ENCARG(mul))
   ENCARG(cons_app(cons_sum, cons_sum)) -> c9(APP(sum, sum), ENCARG(cons_sum))
   ENCARG(cons_app(cons_sum, cons_prod)) -> c9(APP(sum, prod), ENCARG(cons_prod))
   ENCARG(cons_app(cons_sum, x0)) -> c9(APP(app(app(fold, add), 0), encArg(x0)), ENCARG(x0))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_1, c9_2, c29_2, c1_1, c_1, c9_3


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

(139) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 11 trailing tuple parts
----------------------------------------

(140)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s))
   ENCARG(cons_app(cons_sum, times)) -> c9(APP(sum, times))
   ENCARG(cons_app(cons_prod, times)) -> c9(APP(prod, times))
   ENCARG(cons_app(cons_sum, add)) -> c9(APP(sum, add))
   ENCARG(cons_app(cons_prod, add)) -> c9(APP(prod, add))
   ENCARG(cons_app(cons_sum, mul)) -> c9(APP(sum, mul))
   ENCARG(cons_app(cons_prod, mul)) -> c9(APP(prod, mul))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), app(app(fold, add), 0)), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_sum)) -> c9(APP(sum, sum))
   ENCARG(cons_app(cons_prod, cons_sum)) -> c9(APP(prod, sum))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), app(app(fold, mul), app(s, 0))), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_prod)) -> c9(APP(sum, prod))
   ENCARG(cons_app(cons_prod, cons_prod)) -> c9(APP(prod, prod))
   ENCARG(cons_app(cons_sum, x0)) -> c9(APP(app(app(fold, add), 0), encArg(x0)), ENCARG(x0))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_1, c9_2, c29_2, c1_1, c_1, c9_3


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

(141) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace ENCARG(cons_app(cons_prod, x1)) -> c9(APP(prod, encArg(x1)), ENCARG(x1)) by 
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold), ENCARG(fold))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil), ENCARG(nil))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons), ENCARG(cons))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus), ENCARG(plus))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0), ENCARG(0))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s), ENCARG(s))
   ENCARG(cons_app(cons_prod, times)) -> c9(APP(prod, times), ENCARG(times))
   ENCARG(cons_app(cons_prod, add)) -> c9(APP(prod, add), ENCARG(add))
   ENCARG(cons_app(cons_prod, mul)) -> c9(APP(prod, mul), ENCARG(mul))
   ENCARG(cons_app(cons_prod, cons_app(z0, z1))) -> c9(APP(prod, app(encArg(z0), encArg(z1))), ENCARG(cons_app(z0, z1)))
   ENCARG(cons_app(cons_prod, cons_sum)) -> c9(APP(prod, sum), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, cons_prod)) -> c9(APP(prod, prod), ENCARG(cons_prod))
   ENCARG(cons_app(cons_prod, x0)) -> c9(APP(app(app(fold, mul), app(s, 0)), encArg(x0)), ENCARG(x0))

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

(142)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s))
   ENCARG(cons_app(cons_sum, times)) -> c9(APP(sum, times))
   ENCARG(cons_app(cons_prod, times)) -> c9(APP(prod, times))
   ENCARG(cons_app(cons_sum, add)) -> c9(APP(sum, add))
   ENCARG(cons_app(cons_prod, add)) -> c9(APP(prod, add))
   ENCARG(cons_app(cons_sum, mul)) -> c9(APP(sum, mul))
   ENCARG(cons_app(cons_prod, mul)) -> c9(APP(prod, mul))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), app(app(fold, add), 0)), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_sum)) -> c9(APP(sum, sum))
   ENCARG(cons_app(cons_prod, cons_sum)) -> c9(APP(prod, sum))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), app(app(fold, mul), app(s, 0))), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_prod)) -> c9(APP(sum, prod))
   ENCARG(cons_app(cons_prod, cons_prod)) -> c9(APP(prod, prod))
   ENCARG(cons_app(cons_sum, x0)) -> c9(APP(app(app(fold, add), 0), encArg(x0)), ENCARG(x0))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold), ENCARG(fold))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil), ENCARG(nil))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons), ENCARG(cons))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus), ENCARG(plus))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0), ENCARG(0))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s), ENCARG(s))
   ENCARG(cons_app(cons_prod, times)) -> c9(APP(prod, times), ENCARG(times))
   ENCARG(cons_app(cons_prod, add)) -> c9(APP(prod, add), ENCARG(add))
   ENCARG(cons_app(cons_prod, mul)) -> c9(APP(prod, mul), ENCARG(mul))
   ENCARG(cons_app(cons_prod, cons_sum)) -> c9(APP(prod, sum), ENCARG(cons_sum))
   ENCARG(cons_app(cons_prod, cons_prod)) -> c9(APP(prod, prod), ENCARG(cons_prod))
   ENCARG(cons_app(cons_prod, x0)) -> c9(APP(app(app(fold, mul), app(s, 0)), encArg(x0)), ENCARG(x0))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_1, c29_2, c1_1, c_1, c9_3, c9_2


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

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

(144)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s))
   ENCARG(cons_app(cons_sum, times)) -> c9(APP(sum, times))
   ENCARG(cons_app(cons_prod, times)) -> c9(APP(prod, times))
   ENCARG(cons_app(cons_sum, add)) -> c9(APP(sum, add))
   ENCARG(cons_app(cons_prod, add)) -> c9(APP(prod, add))
   ENCARG(cons_app(cons_sum, mul)) -> c9(APP(sum, mul))
   ENCARG(cons_app(cons_prod, mul)) -> c9(APP(prod, mul))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), app(app(fold, add), 0)), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_sum)) -> c9(APP(sum, sum))
   ENCARG(cons_app(cons_prod, cons_sum)) -> c9(APP(prod, sum))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), app(app(fold, mul), app(s, 0))), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_prod)) -> c9(APP(sum, prod))
   ENCARG(cons_app(cons_prod, cons_prod)) -> c9(APP(prod, prod))
   ENCARG(cons_app(cons_sum, x0)) -> c9(APP(app(app(fold, add), 0), encArg(x0)), ENCARG(x0))
   ENCARG(cons_app(cons_prod, x0)) -> c9(APP(app(app(fold, mul), app(s, 0)), encArg(x0)), ENCARG(x0))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_1, c29_2, c1_1, c_1, c9_3, c9_2


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

(145) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace APP(app(times, app(s, app(s, z0))), z1) -> c29(APP(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1), APP(app(times, app(s, z0)), z1)) by 
   APP(app(times, app(s, app(s, 0))), z0) -> c29(APP(app(plus, app(app(plus, 0), z0)), z0), APP(app(times, app(s, 0)), z0))
   APP(app(times, app(s, app(s, app(s, z0)))), z1) -> c29(APP(app(plus, app(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1)), z1), APP(app(times, app(s, app(s, z0))), z1))

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

(146)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s))
   ENCARG(cons_app(cons_sum, times)) -> c9(APP(sum, times))
   ENCARG(cons_app(cons_prod, times)) -> c9(APP(prod, times))
   ENCARG(cons_app(cons_sum, add)) -> c9(APP(sum, add))
   ENCARG(cons_app(cons_prod, add)) -> c9(APP(prod, add))
   ENCARG(cons_app(cons_sum, mul)) -> c9(APP(sum, mul))
   ENCARG(cons_app(cons_prod, mul)) -> c9(APP(prod, mul))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), app(app(fold, add), 0)), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_sum)) -> c9(APP(sum, sum))
   ENCARG(cons_app(cons_prod, cons_sum)) -> c9(APP(prod, sum))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), app(app(fold, mul), app(s, 0))), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_prod)) -> c9(APP(sum, prod))
   ENCARG(cons_app(cons_prod, cons_prod)) -> c9(APP(prod, prod))
   ENCARG(cons_app(cons_sum, x0)) -> c9(APP(app(app(fold, add), 0), encArg(x0)), ENCARG(x0))
   ENCARG(cons_app(cons_prod, x0)) -> c9(APP(app(app(fold, mul), app(s, 0)), encArg(x0)), ENCARG(x0))
   APP(app(times, app(s, app(s, 0))), z0) -> c29(APP(app(plus, app(app(plus, 0), z0)), z0), APP(app(times, app(s, 0)), z0))
   APP(app(times, app(s, app(s, app(s, z0)))), z1) -> c29(APP(app(plus, app(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1)), z1), APP(app(times, app(s, app(s, z0))), z1))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   APP(app(times, app(s, app(s, 0))), z0) -> c29(APP(app(plus, app(app(plus, 0), z0)), z0), APP(app(times, app(s, 0)), z0))
   APP(app(times, app(s, app(s, app(s, z0)))), z1) -> c29(APP(app(plus, app(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1)), z1), APP(app(times, app(s, app(s, z0))), z1))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_1, c1_1, c_1, c9_3, c9_2, c29_2


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

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

(148)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s))
   ENCARG(cons_app(cons_sum, times)) -> c9(APP(sum, times))
   ENCARG(cons_app(cons_prod, times)) -> c9(APP(prod, times))
   ENCARG(cons_app(cons_sum, add)) -> c9(APP(sum, add))
   ENCARG(cons_app(cons_prod, add)) -> c9(APP(prod, add))
   ENCARG(cons_app(cons_sum, mul)) -> c9(APP(sum, mul))
   ENCARG(cons_app(cons_prod, mul)) -> c9(APP(prod, mul))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), app(app(fold, add), 0)), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_sum)) -> c9(APP(sum, sum))
   ENCARG(cons_app(cons_prod, cons_sum)) -> c9(APP(prod, sum))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), app(app(fold, mul), app(s, 0))), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_prod)) -> c9(APP(sum, prod))
   ENCARG(cons_app(cons_prod, cons_prod)) -> c9(APP(prod, prod))
   ENCARG(cons_app(cons_sum, x0)) -> c9(APP(app(app(fold, add), 0), encArg(x0)), ENCARG(x0))
   ENCARG(cons_app(cons_prod, x0)) -> c9(APP(app(app(fold, mul), app(s, 0)), encArg(x0)), ENCARG(x0))
   APP(app(times, app(s, app(s, app(s, z0)))), z1) -> c29(APP(app(plus, app(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1)), z1), APP(app(times, app(s, app(s, z0))), z1))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(plus, app(app(plus, 0), z0)), z0))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(times, app(s, 0)), z0))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   APP(app(times, app(s, app(s, app(s, z0)))), z1) -> c29(APP(app(plus, app(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1)), z1), APP(app(times, app(s, app(s, z0))), z1))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(plus, app(app(plus, 0), z0)), z0))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(times, app(s, 0)), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_1, c1_1, c_1, c9_3, c9_2, c29_2, c2_1


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

(149) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace ENCODE_APP(x0, fold) -> c(APP(encArg(x0), fold)) by 
   ENCODE_APP(fold, fold) -> c(APP(fold, fold))
   ENCODE_APP(nil, fold) -> c(APP(nil, fold))
   ENCODE_APP(cons, fold) -> c(APP(cons, fold))
   ENCODE_APP(plus, fold) -> c(APP(plus, fold))
   ENCODE_APP(0, fold) -> c(APP(0, fold))
   ENCODE_APP(s, fold) -> c(APP(s, fold))
   ENCODE_APP(times, fold) -> c(APP(times, fold))
   ENCODE_APP(add, fold) -> c(APP(add, fold))
   ENCODE_APP(mul, fold) -> c(APP(mul, fold))
   ENCODE_APP(cons_app(z0, z1), fold) -> c(APP(app(encArg(z0), encArg(z1)), fold))
   ENCODE_APP(cons_sum, fold) -> c(APP(sum, fold))
   ENCODE_APP(cons_prod, fold) -> c(APP(prod, fold))

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

(150)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s))
   ENCARG(cons_app(cons_sum, times)) -> c9(APP(sum, times))
   ENCARG(cons_app(cons_prod, times)) -> c9(APP(prod, times))
   ENCARG(cons_app(cons_sum, add)) -> c9(APP(sum, add))
   ENCARG(cons_app(cons_prod, add)) -> c9(APP(prod, add))
   ENCARG(cons_app(cons_sum, mul)) -> c9(APP(sum, mul))
   ENCARG(cons_app(cons_prod, mul)) -> c9(APP(prod, mul))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), app(app(fold, add), 0)), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_sum)) -> c9(APP(sum, sum))
   ENCARG(cons_app(cons_prod, cons_sum)) -> c9(APP(prod, sum))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), app(app(fold, mul), app(s, 0))), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_prod)) -> c9(APP(sum, prod))
   ENCARG(cons_app(cons_prod, cons_prod)) -> c9(APP(prod, prod))
   ENCARG(cons_app(cons_sum, x0)) -> c9(APP(app(app(fold, add), 0), encArg(x0)), ENCARG(x0))
   ENCARG(cons_app(cons_prod, x0)) -> c9(APP(app(app(fold, mul), app(s, 0)), encArg(x0)), ENCARG(x0))
   APP(app(times, app(s, app(s, app(s, z0)))), z1) -> c29(APP(app(plus, app(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1)), z1), APP(app(times, app(s, app(s, z0))), z1))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(plus, app(app(plus, 0), z0)), z0))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(times, app(s, 0)), z0))
   ENCODE_APP(fold, fold) -> c(APP(fold, fold))
   ENCODE_APP(nil, fold) -> c(APP(nil, fold))
   ENCODE_APP(cons, fold) -> c(APP(cons, fold))
   ENCODE_APP(plus, fold) -> c(APP(plus, fold))
   ENCODE_APP(0, fold) -> c(APP(0, fold))
   ENCODE_APP(s, fold) -> c(APP(s, fold))
   ENCODE_APP(times, fold) -> c(APP(times, fold))
   ENCODE_APP(add, fold) -> c(APP(add, fold))
   ENCODE_APP(mul, fold) -> c(APP(mul, fold))
   ENCODE_APP(cons_app(z0, z1), fold) -> c(APP(app(encArg(z0), encArg(z1)), fold))
   ENCODE_APP(cons_sum, fold) -> c(APP(sum, fold))
   ENCODE_APP(cons_prod, fold) -> c(APP(prod, fold))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   APP(app(times, app(s, app(s, app(s, z0)))), z1) -> c29(APP(app(plus, app(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1)), z1), APP(app(times, app(s, app(s, z0))), z1))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(plus, app(app(plus, 0), z0)), z0))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(times, app(s, 0)), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_1, c1_1, c_1, c9_3, c9_2, c29_2, c2_1


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

(151) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 9 trailing nodes:
   ENCODE_APP(0, fold) -> c(APP(0, fold))
   ENCODE_APP(fold, fold) -> c(APP(fold, fold))
   ENCODE_APP(times, fold) -> c(APP(times, fold))
   ENCODE_APP(mul, fold) -> c(APP(mul, fold))
   ENCODE_APP(add, fold) -> c(APP(add, fold))
   ENCODE_APP(plus, fold) -> c(APP(plus, fold))
   ENCODE_APP(nil, fold) -> c(APP(nil, fold))
   ENCODE_APP(cons, fold) -> c(APP(cons, fold))
   ENCODE_APP(s, fold) -> c(APP(s, fold))

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

(152)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s))
   ENCARG(cons_app(cons_sum, times)) -> c9(APP(sum, times))
   ENCARG(cons_app(cons_prod, times)) -> c9(APP(prod, times))
   ENCARG(cons_app(cons_sum, add)) -> c9(APP(sum, add))
   ENCARG(cons_app(cons_prod, add)) -> c9(APP(prod, add))
   ENCARG(cons_app(cons_sum, mul)) -> c9(APP(sum, mul))
   ENCARG(cons_app(cons_prod, mul)) -> c9(APP(prod, mul))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), app(app(fold, add), 0)), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_sum)) -> c9(APP(sum, sum))
   ENCARG(cons_app(cons_prod, cons_sum)) -> c9(APP(prod, sum))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), app(app(fold, mul), app(s, 0))), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_prod)) -> c9(APP(sum, prod))
   ENCARG(cons_app(cons_prod, cons_prod)) -> c9(APP(prod, prod))
   ENCARG(cons_app(cons_sum, x0)) -> c9(APP(app(app(fold, add), 0), encArg(x0)), ENCARG(x0))
   ENCARG(cons_app(cons_prod, x0)) -> c9(APP(app(app(fold, mul), app(s, 0)), encArg(x0)), ENCARG(x0))
   APP(app(times, app(s, app(s, app(s, z0)))), z1) -> c29(APP(app(plus, app(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1)), z1), APP(app(times, app(s, app(s, z0))), z1))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(plus, app(app(plus, 0), z0)), z0))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(times, app(s, 0)), z0))
   ENCODE_APP(cons_app(z0, z1), fold) -> c(APP(app(encArg(z0), encArg(z1)), fold))
   ENCODE_APP(cons_sum, fold) -> c(APP(sum, fold))
   ENCODE_APP(cons_prod, fold) -> c(APP(prod, fold))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   APP(app(times, app(s, app(s, app(s, z0)))), z1) -> c29(APP(app(plus, app(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1)), z1), APP(app(times, app(s, app(s, z0))), z1))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(plus, app(app(plus, 0), z0)), z0))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(times, app(s, 0)), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_1, c1_1, c_1, c9_3, c9_2, c29_2, c2_1


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

(153) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace ENCODE_APP(x0, nil) -> c(APP(encArg(x0), nil)) by 
   ENCODE_APP(fold, nil) -> c(APP(fold, nil))
   ENCODE_APP(nil, nil) -> c(APP(nil, nil))
   ENCODE_APP(cons, nil) -> c(APP(cons, nil))
   ENCODE_APP(plus, nil) -> c(APP(plus, nil))
   ENCODE_APP(0, nil) -> c(APP(0, nil))
   ENCODE_APP(s, nil) -> c(APP(s, nil))
   ENCODE_APP(times, nil) -> c(APP(times, nil))
   ENCODE_APP(add, nil) -> c(APP(add, nil))
   ENCODE_APP(mul, nil) -> c(APP(mul, nil))
   ENCODE_APP(cons_app(z0, z1), nil) -> c(APP(app(encArg(z0), encArg(z1)), nil))
   ENCODE_APP(cons_sum, nil) -> c(APP(sum, nil))
   ENCODE_APP(cons_prod, nil) -> c(APP(prod, nil))

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

(154)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s))
   ENCARG(cons_app(cons_sum, times)) -> c9(APP(sum, times))
   ENCARG(cons_app(cons_prod, times)) -> c9(APP(prod, times))
   ENCARG(cons_app(cons_sum, add)) -> c9(APP(sum, add))
   ENCARG(cons_app(cons_prod, add)) -> c9(APP(prod, add))
   ENCARG(cons_app(cons_sum, mul)) -> c9(APP(sum, mul))
   ENCARG(cons_app(cons_prod, mul)) -> c9(APP(prod, mul))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), app(app(fold, add), 0)), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_sum)) -> c9(APP(sum, sum))
   ENCARG(cons_app(cons_prod, cons_sum)) -> c9(APP(prod, sum))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), app(app(fold, mul), app(s, 0))), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_prod)) -> c9(APP(sum, prod))
   ENCARG(cons_app(cons_prod, cons_prod)) -> c9(APP(prod, prod))
   ENCARG(cons_app(cons_sum, x0)) -> c9(APP(app(app(fold, add), 0), encArg(x0)), ENCARG(x0))
   ENCARG(cons_app(cons_prod, x0)) -> c9(APP(app(app(fold, mul), app(s, 0)), encArg(x0)), ENCARG(x0))
   APP(app(times, app(s, app(s, app(s, z0)))), z1) -> c29(APP(app(plus, app(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1)), z1), APP(app(times, app(s, app(s, z0))), z1))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(plus, app(app(plus, 0), z0)), z0))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(times, app(s, 0)), z0))
   ENCODE_APP(cons_app(z0, z1), fold) -> c(APP(app(encArg(z0), encArg(z1)), fold))
   ENCODE_APP(cons_sum, fold) -> c(APP(sum, fold))
   ENCODE_APP(cons_prod, fold) -> c(APP(prod, fold))
   ENCODE_APP(fold, nil) -> c(APP(fold, nil))
   ENCODE_APP(nil, nil) -> c(APP(nil, nil))
   ENCODE_APP(cons, nil) -> c(APP(cons, nil))
   ENCODE_APP(plus, nil) -> c(APP(plus, nil))
   ENCODE_APP(0, nil) -> c(APP(0, nil))
   ENCODE_APP(s, nil) -> c(APP(s, nil))
   ENCODE_APP(times, nil) -> c(APP(times, nil))
   ENCODE_APP(add, nil) -> c(APP(add, nil))
   ENCODE_APP(mul, nil) -> c(APP(mul, nil))
   ENCODE_APP(cons_app(z0, z1), nil) -> c(APP(app(encArg(z0), encArg(z1)), nil))
   ENCODE_APP(cons_sum, nil) -> c(APP(sum, nil))
   ENCODE_APP(cons_prod, nil) -> c(APP(prod, nil))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   APP(app(times, app(s, app(s, app(s, z0)))), z1) -> c29(APP(app(plus, app(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1)), z1), APP(app(times, app(s, app(s, z0))), z1))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(plus, app(app(plus, 0), z0)), z0))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(times, app(s, 0)), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_1, c1_1, c_1, c9_3, c9_2, c29_2, c2_1


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

(155) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 9 trailing nodes:
   ENCODE_APP(cons, nil) -> c(APP(cons, nil))
   ENCODE_APP(s, nil) -> c(APP(s, nil))
   ENCODE_APP(mul, nil) -> c(APP(mul, nil))
   ENCODE_APP(0, nil) -> c(APP(0, nil))
   ENCODE_APP(times, nil) -> c(APP(times, nil))
   ENCODE_APP(nil, nil) -> c(APP(nil, nil))
   ENCODE_APP(fold, nil) -> c(APP(fold, nil))
   ENCODE_APP(add, nil) -> c(APP(add, nil))
   ENCODE_APP(plus, nil) -> c(APP(plus, nil))

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

(156)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s))
   ENCARG(cons_app(cons_sum, times)) -> c9(APP(sum, times))
   ENCARG(cons_app(cons_prod, times)) -> c9(APP(prod, times))
   ENCARG(cons_app(cons_sum, add)) -> c9(APP(sum, add))
   ENCARG(cons_app(cons_prod, add)) -> c9(APP(prod, add))
   ENCARG(cons_app(cons_sum, mul)) -> c9(APP(sum, mul))
   ENCARG(cons_app(cons_prod, mul)) -> c9(APP(prod, mul))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), app(app(fold, add), 0)), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_sum)) -> c9(APP(sum, sum))
   ENCARG(cons_app(cons_prod, cons_sum)) -> c9(APP(prod, sum))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), app(app(fold, mul), app(s, 0))), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_prod)) -> c9(APP(sum, prod))
   ENCARG(cons_app(cons_prod, cons_prod)) -> c9(APP(prod, prod))
   ENCARG(cons_app(cons_sum, x0)) -> c9(APP(app(app(fold, add), 0), encArg(x0)), ENCARG(x0))
   ENCARG(cons_app(cons_prod, x0)) -> c9(APP(app(app(fold, mul), app(s, 0)), encArg(x0)), ENCARG(x0))
   APP(app(times, app(s, app(s, app(s, z0)))), z1) -> c29(APP(app(plus, app(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1)), z1), APP(app(times, app(s, app(s, z0))), z1))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(plus, app(app(plus, 0), z0)), z0))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(times, app(s, 0)), z0))
   ENCODE_APP(cons_app(z0, z1), fold) -> c(APP(app(encArg(z0), encArg(z1)), fold))
   ENCODE_APP(cons_sum, fold) -> c(APP(sum, fold))
   ENCODE_APP(cons_prod, fold) -> c(APP(prod, fold))
   ENCODE_APP(cons_app(z0, z1), nil) -> c(APP(app(encArg(z0), encArg(z1)), nil))
   ENCODE_APP(cons_sum, nil) -> c(APP(sum, nil))
   ENCODE_APP(cons_prod, nil) -> c(APP(prod, nil))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   APP(app(times, app(s, app(s, app(s, z0)))), z1) -> c29(APP(app(plus, app(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1)), z1), APP(app(times, app(s, app(s, z0))), z1))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(plus, app(app(plus, 0), z0)), z0))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(times, app(s, 0)), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_1, c1_1, c_1, c9_3, c9_2, c29_2, c2_1


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

(157) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace ENCODE_APP(x0, cons) -> c(APP(encArg(x0), cons)) by 
   ENCODE_APP(fold, cons) -> c(APP(fold, cons))
   ENCODE_APP(nil, cons) -> c(APP(nil, cons))
   ENCODE_APP(cons, cons) -> c(APP(cons, cons))
   ENCODE_APP(plus, cons) -> c(APP(plus, cons))
   ENCODE_APP(0, cons) -> c(APP(0, cons))
   ENCODE_APP(s, cons) -> c(APP(s, cons))
   ENCODE_APP(times, cons) -> c(APP(times, cons))
   ENCODE_APP(add, cons) -> c(APP(add, cons))
   ENCODE_APP(mul, cons) -> c(APP(mul, cons))
   ENCODE_APP(cons_app(z0, z1), cons) -> c(APP(app(encArg(z0), encArg(z1)), cons))
   ENCODE_APP(cons_sum, cons) -> c(APP(sum, cons))
   ENCODE_APP(cons_prod, cons) -> c(APP(prod, cons))

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

(158)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s))
   ENCARG(cons_app(cons_sum, times)) -> c9(APP(sum, times))
   ENCARG(cons_app(cons_prod, times)) -> c9(APP(prod, times))
   ENCARG(cons_app(cons_sum, add)) -> c9(APP(sum, add))
   ENCARG(cons_app(cons_prod, add)) -> c9(APP(prod, add))
   ENCARG(cons_app(cons_sum, mul)) -> c9(APP(sum, mul))
   ENCARG(cons_app(cons_prod, mul)) -> c9(APP(prod, mul))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), app(app(fold, add), 0)), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_sum)) -> c9(APP(sum, sum))
   ENCARG(cons_app(cons_prod, cons_sum)) -> c9(APP(prod, sum))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), app(app(fold, mul), app(s, 0))), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_prod)) -> c9(APP(sum, prod))
   ENCARG(cons_app(cons_prod, cons_prod)) -> c9(APP(prod, prod))
   ENCARG(cons_app(cons_sum, x0)) -> c9(APP(app(app(fold, add), 0), encArg(x0)), ENCARG(x0))
   ENCARG(cons_app(cons_prod, x0)) -> c9(APP(app(app(fold, mul), app(s, 0)), encArg(x0)), ENCARG(x0))
   APP(app(times, app(s, app(s, app(s, z0)))), z1) -> c29(APP(app(plus, app(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1)), z1), APP(app(times, app(s, app(s, z0))), z1))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(plus, app(app(plus, 0), z0)), z0))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(times, app(s, 0)), z0))
   ENCODE_APP(cons_app(z0, z1), fold) -> c(APP(app(encArg(z0), encArg(z1)), fold))
   ENCODE_APP(cons_sum, fold) -> c(APP(sum, fold))
   ENCODE_APP(cons_prod, fold) -> c(APP(prod, fold))
   ENCODE_APP(cons_app(z0, z1), nil) -> c(APP(app(encArg(z0), encArg(z1)), nil))
   ENCODE_APP(cons_sum, nil) -> c(APP(sum, nil))
   ENCODE_APP(cons_prod, nil) -> c(APP(prod, nil))
   ENCODE_APP(fold, cons) -> c(APP(fold, cons))
   ENCODE_APP(nil, cons) -> c(APP(nil, cons))
   ENCODE_APP(cons, cons) -> c(APP(cons, cons))
   ENCODE_APP(plus, cons) -> c(APP(plus, cons))
   ENCODE_APP(0, cons) -> c(APP(0, cons))
   ENCODE_APP(s, cons) -> c(APP(s, cons))
   ENCODE_APP(times, cons) -> c(APP(times, cons))
   ENCODE_APP(add, cons) -> c(APP(add, cons))
   ENCODE_APP(mul, cons) -> c(APP(mul, cons))
   ENCODE_APP(cons_app(z0, z1), cons) -> c(APP(app(encArg(z0), encArg(z1)), cons))
   ENCODE_APP(cons_sum, cons) -> c(APP(sum, cons))
   ENCODE_APP(cons_prod, cons) -> c(APP(prod, cons))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   APP(app(times, app(s, app(s, app(s, z0)))), z1) -> c29(APP(app(plus, app(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1)), z1), APP(app(times, app(s, app(s, z0))), z1))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(plus, app(app(plus, 0), z0)), z0))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(times, app(s, 0)), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_1, c1_1, c_1, c9_3, c9_2, c29_2, c2_1


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

(159) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 9 trailing nodes:
   ENCODE_APP(fold, cons) -> c(APP(fold, cons))
   ENCODE_APP(s, cons) -> c(APP(s, cons))
   ENCODE_APP(cons, cons) -> c(APP(cons, cons))
   ENCODE_APP(add, cons) -> c(APP(add, cons))
   ENCODE_APP(plus, cons) -> c(APP(plus, cons))
   ENCODE_APP(0, cons) -> c(APP(0, cons))
   ENCODE_APP(mul, cons) -> c(APP(mul, cons))
   ENCODE_APP(times, cons) -> c(APP(times, cons))
   ENCODE_APP(nil, cons) -> c(APP(nil, cons))

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

(160)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s))
   ENCARG(cons_app(cons_sum, times)) -> c9(APP(sum, times))
   ENCARG(cons_app(cons_prod, times)) -> c9(APP(prod, times))
   ENCARG(cons_app(cons_sum, add)) -> c9(APP(sum, add))
   ENCARG(cons_app(cons_prod, add)) -> c9(APP(prod, add))
   ENCARG(cons_app(cons_sum, mul)) -> c9(APP(sum, mul))
   ENCARG(cons_app(cons_prod, mul)) -> c9(APP(prod, mul))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), app(app(fold, add), 0)), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_sum)) -> c9(APP(sum, sum))
   ENCARG(cons_app(cons_prod, cons_sum)) -> c9(APP(prod, sum))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), app(app(fold, mul), app(s, 0))), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_prod)) -> c9(APP(sum, prod))
   ENCARG(cons_app(cons_prod, cons_prod)) -> c9(APP(prod, prod))
   ENCARG(cons_app(cons_sum, x0)) -> c9(APP(app(app(fold, add), 0), encArg(x0)), ENCARG(x0))
   ENCARG(cons_app(cons_prod, x0)) -> c9(APP(app(app(fold, mul), app(s, 0)), encArg(x0)), ENCARG(x0))
   APP(app(times, app(s, app(s, app(s, z0)))), z1) -> c29(APP(app(plus, app(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1)), z1), APP(app(times, app(s, app(s, z0))), z1))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(plus, app(app(plus, 0), z0)), z0))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(times, app(s, 0)), z0))
   ENCODE_APP(cons_app(z0, z1), fold) -> c(APP(app(encArg(z0), encArg(z1)), fold))
   ENCODE_APP(cons_sum, fold) -> c(APP(sum, fold))
   ENCODE_APP(cons_prod, fold) -> c(APP(prod, fold))
   ENCODE_APP(cons_app(z0, z1), nil) -> c(APP(app(encArg(z0), encArg(z1)), nil))
   ENCODE_APP(cons_sum, nil) -> c(APP(sum, nil))
   ENCODE_APP(cons_prod, nil) -> c(APP(prod, nil))
   ENCODE_APP(cons_app(z0, z1), cons) -> c(APP(app(encArg(z0), encArg(z1)), cons))
   ENCODE_APP(cons_sum, cons) -> c(APP(sum, cons))
   ENCODE_APP(cons_prod, cons) -> c(APP(prod, cons))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   APP(app(times, app(s, app(s, app(s, z0)))), z1) -> c29(APP(app(plus, app(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1)), z1), APP(app(times, app(s, app(s, z0))), z1))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(plus, app(app(plus, 0), z0)), z0))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(times, app(s, 0)), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_1, c1_1, c_1, c9_3, c9_2, c29_2, c2_1


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

(161) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace ENCODE_APP(x0, plus) -> c(APP(encArg(x0), plus)) by 
   ENCODE_APP(fold, plus) -> c(APP(fold, plus))
   ENCODE_APP(nil, plus) -> c(APP(nil, plus))
   ENCODE_APP(cons, plus) -> c(APP(cons, plus))
   ENCODE_APP(plus, plus) -> c(APP(plus, plus))
   ENCODE_APP(0, plus) -> c(APP(0, plus))
   ENCODE_APP(s, plus) -> c(APP(s, plus))
   ENCODE_APP(times, plus) -> c(APP(times, plus))
   ENCODE_APP(add, plus) -> c(APP(add, plus))
   ENCODE_APP(mul, plus) -> c(APP(mul, plus))
   ENCODE_APP(cons_app(z0, z1), plus) -> c(APP(app(encArg(z0), encArg(z1)), plus))
   ENCODE_APP(cons_sum, plus) -> c(APP(sum, plus))
   ENCODE_APP(cons_prod, plus) -> c(APP(prod, plus))

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

(162)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s))
   ENCARG(cons_app(cons_sum, times)) -> c9(APP(sum, times))
   ENCARG(cons_app(cons_prod, times)) -> c9(APP(prod, times))
   ENCARG(cons_app(cons_sum, add)) -> c9(APP(sum, add))
   ENCARG(cons_app(cons_prod, add)) -> c9(APP(prod, add))
   ENCARG(cons_app(cons_sum, mul)) -> c9(APP(sum, mul))
   ENCARG(cons_app(cons_prod, mul)) -> c9(APP(prod, mul))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), app(app(fold, add), 0)), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_sum)) -> c9(APP(sum, sum))
   ENCARG(cons_app(cons_prod, cons_sum)) -> c9(APP(prod, sum))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), app(app(fold, mul), app(s, 0))), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_prod)) -> c9(APP(sum, prod))
   ENCARG(cons_app(cons_prod, cons_prod)) -> c9(APP(prod, prod))
   ENCARG(cons_app(cons_sum, x0)) -> c9(APP(app(app(fold, add), 0), encArg(x0)), ENCARG(x0))
   ENCARG(cons_app(cons_prod, x0)) -> c9(APP(app(app(fold, mul), app(s, 0)), encArg(x0)), ENCARG(x0))
   APP(app(times, app(s, app(s, app(s, z0)))), z1) -> c29(APP(app(plus, app(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1)), z1), APP(app(times, app(s, app(s, z0))), z1))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(plus, app(app(plus, 0), z0)), z0))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(times, app(s, 0)), z0))
   ENCODE_APP(cons_app(z0, z1), fold) -> c(APP(app(encArg(z0), encArg(z1)), fold))
   ENCODE_APP(cons_sum, fold) -> c(APP(sum, fold))
   ENCODE_APP(cons_prod, fold) -> c(APP(prod, fold))
   ENCODE_APP(cons_app(z0, z1), nil) -> c(APP(app(encArg(z0), encArg(z1)), nil))
   ENCODE_APP(cons_sum, nil) -> c(APP(sum, nil))
   ENCODE_APP(cons_prod, nil) -> c(APP(prod, nil))
   ENCODE_APP(cons_app(z0, z1), cons) -> c(APP(app(encArg(z0), encArg(z1)), cons))
   ENCODE_APP(cons_sum, cons) -> c(APP(sum, cons))
   ENCODE_APP(cons_prod, cons) -> c(APP(prod, cons))
   ENCODE_APP(fold, plus) -> c(APP(fold, plus))
   ENCODE_APP(nil, plus) -> c(APP(nil, plus))
   ENCODE_APP(cons, plus) -> c(APP(cons, plus))
   ENCODE_APP(plus, plus) -> c(APP(plus, plus))
   ENCODE_APP(0, plus) -> c(APP(0, plus))
   ENCODE_APP(s, plus) -> c(APP(s, plus))
   ENCODE_APP(times, plus) -> c(APP(times, plus))
   ENCODE_APP(add, plus) -> c(APP(add, plus))
   ENCODE_APP(mul, plus) -> c(APP(mul, plus))
   ENCODE_APP(cons_app(z0, z1), plus) -> c(APP(app(encArg(z0), encArg(z1)), plus))
   ENCODE_APP(cons_sum, plus) -> c(APP(sum, plus))
   ENCODE_APP(cons_prod, plus) -> c(APP(prod, plus))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   APP(app(times, app(s, app(s, app(s, z0)))), z1) -> c29(APP(app(plus, app(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1)), z1), APP(app(times, app(s, app(s, z0))), z1))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(plus, app(app(plus, 0), z0)), z0))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(times, app(s, 0)), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_1, c1_1, c_1, c9_3, c9_2, c29_2, c2_1


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

(163) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 9 trailing nodes:
   ENCODE_APP(fold, plus) -> c(APP(fold, plus))
   ENCODE_APP(cons, plus) -> c(APP(cons, plus))
   ENCODE_APP(nil, plus) -> c(APP(nil, plus))
   ENCODE_APP(s, plus) -> c(APP(s, plus))
   ENCODE_APP(add, plus) -> c(APP(add, plus))
   ENCODE_APP(plus, plus) -> c(APP(plus, plus))
   ENCODE_APP(mul, plus) -> c(APP(mul, plus))
   ENCODE_APP(times, plus) -> c(APP(times, plus))
   ENCODE_APP(0, plus) -> c(APP(0, plus))

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

(164)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   encArg(fold) -> fold
   encArg(nil) -> nil
   encArg(cons) -> cons
   encArg(plus) -> plus
   encArg(0) -> 0
   encArg(s) -> s
   encArg(times) -> times
   encArg(add) -> add
   encArg(mul) -> mul
   encArg(cons_app(z0, z1)) -> app(encArg(z0), encArg(z1))
   encArg(cons_sum) -> sum
   encArg(cons_prod) -> prod
   app(app(app(fold, z0), z1), nil) -> z1
   app(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> app(app(z0, z2), app(app(app(fold, z0), z1), z3))
   app(app(plus, 0), z0) -> z0
   app(app(plus, app(s, z0)), z1) -> app(s, app(app(plus, z0), z1))
   app(app(times, 0), z0) -> 0
   app(app(times, app(s, z0)), z1) -> app(app(plus, app(app(times, z0), z1)), z1)
   sum -> app(app(fold, add), 0)
   prod -> app(app(fold, mul), app(s, 0))
Tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   ENCARG(cons_app(fold, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(nil, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(cons, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(plus, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(0, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(s, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(times, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(add, x1)) -> c9(ENCARG(x1))
   ENCARG(cons_app(mul, x1)) -> c9(ENCARG(x1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   ENCODE_APP(x0, 0) -> c(APP(encArg(x0), 0))
   ENCODE_APP(x0, s) -> c(APP(encArg(x0), s))
   ENCODE_APP(x0, times) -> c(APP(encArg(x0), times))
   ENCODE_APP(x0, add) -> c(APP(encArg(x0), add))
   ENCODE_APP(x0, mul) -> c(APP(encArg(x0), mul))
   ENCODE_APP(x0, cons_app(z0, z1)) -> c(APP(encArg(x0), app(encArg(z0), encArg(z1))))
   ENCODE_APP(x0, cons_sum) -> c(APP(encArg(x0), sum))
   ENCODE_APP(x0, cons_prod) -> c(APP(encArg(x0), prod))
   ENCODE_APP(cons_app(z0, z1), x1) -> c(APP(app(encArg(z0), encArg(z1)), encArg(x1)))
   ENCODE_APP(cons_sum, x1) -> c(APP(sum, encArg(x1)))
   ENCODE_APP(cons_prod, x1) -> c(APP(prod, encArg(x1)))
   ENCARG(cons_app(x0, cons_app(x1, fold))) -> c9(APP(encArg(x0), app(encArg(x1), fold)), ENCARG(x0), ENCARG(cons_app(x1, fold)))
   ENCARG(cons_app(x0, cons_app(x1, nil))) -> c9(APP(encArg(x0), app(encArg(x1), nil)), ENCARG(x0), ENCARG(cons_app(x1, nil)))
   ENCARG(cons_app(x0, cons_app(x1, cons))) -> c9(APP(encArg(x0), app(encArg(x1), cons)), ENCARG(x0), ENCARG(cons_app(x1, cons)))
   ENCARG(cons_app(x0, cons_app(x1, plus))) -> c9(APP(encArg(x0), app(encArg(x1), plus)), ENCARG(x0), ENCARG(cons_app(x1, plus)))
   ENCARG(cons_app(x0, cons_app(x1, 0))) -> c9(APP(encArg(x0), app(encArg(x1), 0)), ENCARG(x0), ENCARG(cons_app(x1, 0)))
   ENCARG(cons_app(x0, cons_app(x1, s))) -> c9(APP(encArg(x0), app(encArg(x1), s)), ENCARG(x0), ENCARG(cons_app(x1, s)))
   ENCARG(cons_app(x0, cons_app(x1, times))) -> c9(APP(encArg(x0), app(encArg(x1), times)), ENCARG(x0), ENCARG(cons_app(x1, times)))
   ENCARG(cons_app(x0, cons_app(x1, add))) -> c9(APP(encArg(x0), app(encArg(x1), add)), ENCARG(x0), ENCARG(cons_app(x1, add)))
   ENCARG(cons_app(x0, cons_app(x1, mul))) -> c9(APP(encArg(x0), app(encArg(x1), mul)), ENCARG(x0), ENCARG(cons_app(x1, mul)))
   ENCARG(cons_app(x0, cons_app(x1, cons_app(z0, z1)))) -> c9(APP(encArg(x0), app(encArg(x1), app(encArg(z0), encArg(z1)))), ENCARG(x0), ENCARG(cons_app(x1, cons_app(z0, z1))))
   ENCARG(cons_app(x0, cons_app(x1, cons_sum))) -> c9(APP(encArg(x0), app(encArg(x1), sum)), ENCARG(x0), ENCARG(cons_app(x1, cons_sum)))
   ENCARG(cons_app(x0, cons_app(x1, cons_prod))) -> c9(APP(encArg(x0), app(encArg(x1), prod)), ENCARG(x0), ENCARG(cons_app(x1, cons_prod)))
   ENCARG(cons_app(x0, cons_app(fold, x2))) -> c9(APP(encArg(x0), app(fold, encArg(x2))), ENCARG(x0), ENCARG(cons_app(fold, x2)))
   ENCARG(cons_app(x0, cons_app(nil, x2))) -> c9(APP(encArg(x0), app(nil, encArg(x2))), ENCARG(x0), ENCARG(cons_app(nil, x2)))
   ENCARG(cons_app(x0, cons_app(cons, x2))) -> c9(APP(encArg(x0), app(cons, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons, x2)))
   ENCARG(cons_app(x0, cons_app(plus, x2))) -> c9(APP(encArg(x0), app(plus, encArg(x2))), ENCARG(x0), ENCARG(cons_app(plus, x2)))
   ENCARG(cons_app(x0, cons_app(0, x2))) -> c9(APP(encArg(x0), app(0, encArg(x2))), ENCARG(x0), ENCARG(cons_app(0, x2)))
   ENCARG(cons_app(x0, cons_app(s, x2))) -> c9(APP(encArg(x0), app(s, encArg(x2))), ENCARG(x0), ENCARG(cons_app(s, x2)))
   ENCARG(cons_app(x0, cons_app(times, x2))) -> c9(APP(encArg(x0), app(times, encArg(x2))), ENCARG(x0), ENCARG(cons_app(times, x2)))
   ENCARG(cons_app(x0, cons_app(add, x2))) -> c9(APP(encArg(x0), app(add, encArg(x2))), ENCARG(x0), ENCARG(cons_app(add, x2)))
   ENCARG(cons_app(x0, cons_app(mul, x2))) -> c9(APP(encArg(x0), app(mul, encArg(x2))), ENCARG(x0), ENCARG(cons_app(mul, x2)))
   ENCARG(cons_app(x0, cons_app(cons_app(z0, z1), x2))) -> c9(APP(encArg(x0), app(app(encArg(z0), encArg(z1)), encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_app(z0, z1), x2)))
   ENCARG(cons_app(x0, cons_app(cons_sum, x2))) -> c9(APP(encArg(x0), app(sum, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_sum, x2)))
   ENCARG(cons_app(x0, cons_app(cons_prod, x2))) -> c9(APP(encArg(x0), app(prod, encArg(x2))), ENCARG(x0), ENCARG(cons_app(cons_prod, x2)))
   ENCARG(cons_app(cons_app(z0, z1), cons_app(x1, x2))) -> c9(APP(app(encArg(z0), encArg(z1)), app(encArg(x1), encArg(x2))), ENCARG(cons_app(z0, z1)), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(fold, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(nil, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(plus, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(0, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(s, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(times, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(add, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(mul, cons_app(x1, x2))) -> c9(ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_sum, cons_app(x1, x2))) -> c9(APP(sum, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_prod, cons_app(x1, x2))) -> c9(APP(prod, app(encArg(x1), encArg(x2))), ENCARG(cons_app(x1, x2)))
   ENCARG(cons_app(cons_app(x0, fold), x2)) -> c9(APP(app(encArg(x0), fold), encArg(x2)), ENCARG(cons_app(x0, fold)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, nil), x2)) -> c9(APP(app(encArg(x0), nil), encArg(x2)), ENCARG(cons_app(x0, nil)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons), x2)) -> c9(APP(app(encArg(x0), cons), encArg(x2)), ENCARG(cons_app(x0, cons)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, plus), x2)) -> c9(APP(app(encArg(x0), plus), encArg(x2)), ENCARG(cons_app(x0, plus)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, 0), x2)) -> c9(APP(app(encArg(x0), 0), encArg(x2)), ENCARG(cons_app(x0, 0)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, s), x2)) -> c9(APP(app(encArg(x0), s), encArg(x2)), ENCARG(cons_app(x0, s)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, times), x2)) -> c9(APP(app(encArg(x0), times), encArg(x2)), ENCARG(cons_app(x0, times)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, add), x2)) -> c9(APP(app(encArg(x0), add), encArg(x2)), ENCARG(cons_app(x0, add)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, mul), x2)) -> c9(APP(app(encArg(x0), mul), encArg(x2)), ENCARG(cons_app(x0, mul)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_app(z0, z1)), x2)) -> c9(APP(app(encArg(x0), app(encArg(z0), encArg(z1))), encArg(x2)), ENCARG(cons_app(x0, cons_app(z0, z1))), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_sum), x2)) -> c9(APP(app(encArg(x0), sum), encArg(x2)), ENCARG(cons_app(x0, cons_sum)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, cons_prod), x2)) -> c9(APP(app(encArg(x0), prod), encArg(x2)), ENCARG(cons_app(x0, cons_prod)), ENCARG(x2))
   ENCARG(cons_app(cons_app(plus, x1), x2)) -> c9(APP(app(plus, encArg(x1)), encArg(x2)), ENCARG(cons_app(plus, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(times, x1), x2)) -> c9(APP(app(times, encArg(x1)), encArg(x2)), ENCARG(cons_app(times, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_app(z0, z1), x1), x2)) -> c9(APP(app(app(encArg(z0), encArg(z1)), encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_app(z0, z1), x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_sum, x1), x2)) -> c9(APP(app(sum, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_sum, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons_prod, x1), x2)) -> c9(APP(app(prod, encArg(x1)), encArg(x2)), ENCARG(cons_app(cons_prod, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(x0, x1), fold)) -> c9(APP(app(encArg(x0), encArg(x1)), fold), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), nil)) -> c9(APP(app(encArg(x0), encArg(x1)), nil), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons)) -> c9(APP(app(encArg(x0), encArg(x1)), cons), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), plus)) -> c9(APP(app(encArg(x0), encArg(x1)), plus), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), 0)) -> c9(APP(app(encArg(x0), encArg(x1)), 0), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), s)) -> c9(APP(app(encArg(x0), encArg(x1)), s), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), times)) -> c9(APP(app(encArg(x0), encArg(x1)), times), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), add)) -> c9(APP(app(encArg(x0), encArg(x1)), add), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), mul)) -> c9(APP(app(encArg(x0), encArg(x1)), mul), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_sum)) -> c9(APP(app(encArg(x0), encArg(x1)), sum), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(x0, x1), cons_prod)) -> c9(APP(app(encArg(x0), encArg(x1)), prod), ENCARG(cons_app(x0, x1)))
   ENCARG(cons_app(cons_app(fold, x1), x2)) -> c9(ENCARG(cons_app(fold, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(nil, x1), x2)) -> c9(ENCARG(cons_app(nil, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(cons, x1), x2)) -> c9(ENCARG(cons_app(cons, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(0, x1), x2)) -> c9(ENCARG(cons_app(0, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(s, x1), x2)) -> c9(ENCARG(cons_app(s, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(add, x1), x2)) -> c9(ENCARG(cons_app(add, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_app(mul, x1), x2)) -> c9(ENCARG(cons_app(mul, x1)), ENCARG(x2))
   ENCARG(cons_app(cons_sum, fold)) -> c9(APP(sum, fold))
   ENCARG(cons_app(cons_prod, fold)) -> c9(APP(prod, fold))
   ENCARG(cons_app(cons_sum, nil)) -> c9(APP(sum, nil))
   ENCARG(cons_app(cons_prod, nil)) -> c9(APP(prod, nil))
   ENCARG(cons_app(cons_sum, cons)) -> c9(APP(sum, cons))
   ENCARG(cons_app(cons_prod, cons)) -> c9(APP(prod, cons))
   ENCARG(cons_app(cons_sum, plus)) -> c9(APP(sum, plus))
   ENCARG(cons_app(cons_prod, plus)) -> c9(APP(prod, plus))
   ENCARG(cons_app(cons_sum, 0)) -> c9(APP(sum, 0))
   ENCARG(cons_app(cons_prod, 0)) -> c9(APP(prod, 0))
   ENCARG(cons_app(cons_sum, s)) -> c9(APP(sum, s))
   ENCARG(cons_app(cons_prod, s)) -> c9(APP(prod, s))
   ENCARG(cons_app(cons_sum, times)) -> c9(APP(sum, times))
   ENCARG(cons_app(cons_prod, times)) -> c9(APP(prod, times))
   ENCARG(cons_app(cons_sum, add)) -> c9(APP(sum, add))
   ENCARG(cons_app(cons_prod, add)) -> c9(APP(prod, add))
   ENCARG(cons_app(cons_sum, mul)) -> c9(APP(sum, mul))
   ENCARG(cons_app(cons_prod, mul)) -> c9(APP(prod, mul))
   ENCARG(cons_app(x0, cons_sum)) -> c9(APP(encArg(x0), app(app(fold, add), 0)), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_sum)) -> c9(APP(sum, sum))
   ENCARG(cons_app(cons_prod, cons_sum)) -> c9(APP(prod, sum))
   ENCARG(cons_app(x0, cons_prod)) -> c9(APP(encArg(x0), app(app(fold, mul), app(s, 0))), ENCARG(x0))
   ENCARG(cons_app(cons_sum, cons_prod)) -> c9(APP(sum, prod))
   ENCARG(cons_app(cons_prod, cons_prod)) -> c9(APP(prod, prod))
   ENCARG(cons_app(cons_sum, x0)) -> c9(APP(app(app(fold, add), 0), encArg(x0)), ENCARG(x0))
   ENCARG(cons_app(cons_prod, x0)) -> c9(APP(app(app(fold, mul), app(s, 0)), encArg(x0)), ENCARG(x0))
   APP(app(times, app(s, app(s, app(s, z0)))), z1) -> c29(APP(app(plus, app(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1)), z1), APP(app(times, app(s, app(s, z0))), z1))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(plus, app(app(plus, 0), z0)), z0))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(times, app(s, 0)), z0))
   ENCODE_APP(cons_app(z0, z1), fold) -> c(APP(app(encArg(z0), encArg(z1)), fold))
   ENCODE_APP(cons_sum, fold) -> c(APP(sum, fold))
   ENCODE_APP(cons_prod, fold) -> c(APP(prod, fold))
   ENCODE_APP(cons_app(z0, z1), nil) -> c(APP(app(encArg(z0), encArg(z1)), nil))
   ENCODE_APP(cons_sum, nil) -> c(APP(sum, nil))
   ENCODE_APP(cons_prod, nil) -> c(APP(prod, nil))
   ENCODE_APP(cons_app(z0, z1), cons) -> c(APP(app(encArg(z0), encArg(z1)), cons))
   ENCODE_APP(cons_sum, cons) -> c(APP(sum, cons))
   ENCODE_APP(cons_prod, cons) -> c(APP(prod, cons))
   ENCODE_APP(cons_app(z0, z1), plus) -> c(APP(app(encArg(z0), encArg(z1)), plus))
   ENCODE_APP(cons_sum, plus) -> c(APP(sum, plus))
   ENCODE_APP(cons_prod, plus) -> c(APP(prod, plus))
S tuples:
   APP(app(app(fold, z0), z1), nil) -> c24
   APP(app(plus, 0), z0) -> c26
   APP(app(times, 0), z0) -> c28
   APP(app(app(fold, z0), z1), app(app(cons, z2), z3)) -> c25(APP(app(z0, z2), app(app(app(fold, z0), z1), z3)), APP(z0, z2), APP(app(app(fold, z0), z1), z3))
   APP(app(plus, app(s, z0)), z1) -> c27(APP(app(plus, z0), z1))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(plus, 0), z0))
   APP(app(times, app(s, 0)), z0) -> c1(APP(app(times, 0), z0))
   APP(app(times, app(s, app(s, app(s, z0)))), z1) -> c29(APP(app(plus, app(app(plus, app(app(plus, app(app(times, z0), z1)), z1)), z1)), z1), APP(app(times, app(s, app(s, z0))), z1))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(plus, app(app(plus, 0), z0)), z0))
   APP(app(times, app(s, app(s, 0))), z0) -> c2(APP(app(times, app(s, 0)), z0))
K tuples:none
Defined Rule Symbols:   encArg_1, app_2, sum, prod

Defined Pair Symbols:   APP_2, ENCARG_1, ENCODE_APP_2

Compound Symbols:   c24, c26, c28, c25_3, c27_1, c9_1, c1_1, c_1, c9_3, c9_2, c29_2, c2_1