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


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

(0) CpxTRS
(1) RenamingProof [BOTH BOUNDS(ID, ID), 0 ms]
(2) CpxTRS
(3) RelTrsToTrsProof [UPPER BOUND(ID), 0 ms]
(4) CpxTRS
(5) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms]
(6) CdtProblem
    (7) CdtToCpxRelTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (8) CpxRelTRS
    (9) RenamingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (10) CpxRelTRS
    (11) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
    (12) typed CpxTrs
    (13) OrderProof [LOWER BOUND(ID), 4 ms]
    (14) typed CpxTrs
    (15) RewriteLemmaProof [LOWER BOUND(ID), 3190 ms]
    (16) BEST
        (17) proven lower bound
            (18) LowerBoundPropagationProof [FINISHED, 0 ms]
            (19) BOUNDS(n^1, INF)
        (20) typed CpxTrs
            (21) RewriteLemmaProof [FINISHED, 9095 ms]
            (22) BOUNDS(EXP, INF)
(23) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms]
(24) CdtProblem
    (25) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (26) CdtProblem
    (27) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (28) CdtProblem
    (29) CdtToCpxRelTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (30) CpxRelTRS
        (31) RelTrsToTrsProof [UPPER BOUND(ID), 0 ms]
        (32) CpxTRS
        (33) RelTrsToWeightedTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
        (34) CpxWeightedTrs
            (35) CpxWeightedTrsRenamingProof [BOTH BOUNDS(ID, ID), 0 ms]
            (36) CpxWeightedTrs
            (37) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
            (38) CpxTypedWeightedTrs
            (39) CompletionProof [UPPER BOUND(ID), 0 ms]
            (40) CpxTypedWeightedCompleteTrs
                (41) NarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
                (42) CpxTypedWeightedCompleteTrs
                (43) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 8 ms]
                (44) CpxRNTS
                (45) SimplificationProof [BOTH BOUNDS(ID, ID), 0 ms]
                (46) CpxRNTS
                (47) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 0 ms]
                (48) CpxRNTS
                (49) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
                (50) CpxRNTS
                (51) IntTrsBoundProof [UPPER BOUND(ID), 189 ms]
                (52) CpxRNTS
                (53) IntTrsBoundProof [UPPER BOUND(ID), 94 ms]
                (54) CpxRNTS
                (55) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
                (56) CpxRNTS
                (57) IntTrsBoundProof [UPPER BOUND(ID), 531 ms]
                (58) CpxRNTS
                (59) IntTrsBoundProof [UPPER BOUND(ID), 84 ms]
                (60) CpxRNTS
                (61) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
                (62) CpxRNTS
                (63) IntTrsBoundProof [UPPER BOUND(ID), 1975 ms]
                (64) CpxRNTS
                (65) IntTrsBoundProof [UPPER BOUND(ID), 29 ms]
                (66) CpxRNTS
                (67) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
                (68) CpxRNTS
                (69) IntTrsBoundProof [UPPER BOUND(ID), 402 ms]
                (70) CpxRNTS
                (71) IntTrsBoundProof [UPPER BOUND(ID), 15 ms]
                (72) CpxRNTS
                (73) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
                (74) CpxRNTS
                (75) IntTrsBoundProof [UPPER BOUND(ID), 953 ms]
                (76) CpxRNTS
                (77) IntTrsBoundProof [UPPER BOUND(ID), 23 ms]
                (78) CpxRNTS
                (79) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
                (80) CpxRNTS
                (81) IntTrsBoundProof [UPPER BOUND(ID), 2314 ms]
                (82) CpxRNTS
                (83) IntTrsBoundProof [UPPER BOUND(ID), 899 ms]
                (84) CpxRNTS
                (85) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
                (86) CpxRNTS
                (87) IntTrsBoundProof [UPPER BOUND(ID), 231 ms]
                (88) CpxRNTS
                (89) IntTrsBoundProof [UPPER BOUND(ID), 155 ms]
                (90) CpxRNTS
                (91) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
                (92) CpxRNTS
                (93) IntTrsBoundProof [UPPER BOUND(ID), 310 ms]
                (94) CpxRNTS
                (95) IntTrsBoundProof [UPPER BOUND(ID), 74 ms]
                (96) CpxRNTS
            (97) CompletionProof [UPPER BOUND(ID), 0 ms]
            (98) CpxTypedWeightedCompleteTrs
                (99) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
                (100) CpxRNTS
    (101) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 117 ms]
    (102) CdtProblem
        (103) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 38 ms]
        (104) CdtProblem
        (105) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (106) CdtProblem
        (107) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
        (108) CdtProblem
        (109) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
        (110) CdtProblem
        (111) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (112) CdtProblem
        (113) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
        (114) CdtProblem
        (115) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (116) CdtProblem
        (117) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
        (118) CdtProblem
        (119) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (120) CdtProblem
        (121) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
        (122) CdtProblem
        (123) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (124) CdtProblem
        (125) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
        (126) CdtProblem
        (127) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (128) CdtProblem
        (129) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 ms]
        (130) CdtProblem
        (131) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (132) CdtProblem
        (133) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
        (134) CdtProblem
        (135) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (136) CdtProblem
        (137) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
        (138) CdtProblem
        (139) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (140) CdtProblem
        (141) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
        (142) CdtProblem
        (143) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (144) CdtProblem
        (145) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
        (146) CdtProblem
        (147) CdtGraphSplitRhsProof [BOTH BOUNDS(ID, ID), 0 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) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (160) CdtProblem
        (161) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (162) CdtProblem
        (163) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (164) CdtProblem
        (165) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
        (166) CdtProblem
        (167) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (168) CdtProblem
        (169) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 6 ms]
        (170) CdtProblem
        (171) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (172) CdtProblem
        (173) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 1 ms]
        (174) CdtProblem
(175) RelTrsToWeightedTrsProof [UPPER BOUND(ID), 0 ms]
(176) CpxWeightedTrs
    (177) CpxWeightedTrsRenamingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (178) CpxWeightedTrs
    (179) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
    (180) CpxTypedWeightedTrs
    (181) CompletionProof [UPPER BOUND(ID), 0 ms]
    (182) CpxTypedWeightedCompleteTrs
        (183) NarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (184) CpxTypedWeightedCompleteTrs
        (185) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
        (186) CpxRNTS
        (187) SimplificationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (188) CpxRNTS
        (189) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 0 ms]
        (190) CpxRNTS
        (191) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (192) CpxRNTS
        (193) IntTrsBoundProof [UPPER BOUND(ID), 371 ms]
        (194) CpxRNTS
        (195) IntTrsBoundProof [UPPER BOUND(ID), 59 ms]
        (196) CpxRNTS
        (197) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (198) CpxRNTS
        (199) IntTrsBoundProof [UPPER BOUND(ID), 875 ms]
        (200) CpxRNTS
        (201) IntTrsBoundProof [UPPER BOUND(ID), 250 ms]
        (202) CpxRNTS
        (203) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (204) CpxRNTS
        (205) IntTrsBoundProof [UPPER BOUND(ID), 202 ms]
        (206) CpxRNTS
        (207) IntTrsBoundProof [UPPER BOUND(ID), 4 ms]
        (208) CpxRNTS
        (209) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (210) CpxRNTS
        (211) IntTrsBoundProof [UPPER BOUND(ID), 903 ms]
        (212) CpxRNTS
        (213) IntTrsBoundProof [UPPER BOUND(ID), 34 ms]
        (214) CpxRNTS
    (215) CompletionProof [UPPER BOUND(ID), 0 ms]
    (216) CpxTypedWeightedCompleteTrs
        (217) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
        (218) CpxRNTS


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

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


The TRS R consists of the following rules:

   +(x, 0) -> x
   +(0, x) -> x
   +(s(x), s(y)) -> s(s(+(x, y)))
   *(x, 0) -> 0
   *(0, x) -> 0
   *(s(x), s(y)) -> s(+(*(x, y), +(x, y)))
   sum(nil) -> 0
   sum(cons(x, l)) -> +(x, sum(l))
   prod(nil) -> s(0)
   prod(cons(x, l)) -> *(x, prod(l))

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

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

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


The TRS R consists of the following rules:

   +'(x, 0') -> x
   +'(0', x) -> x
   +'(s(x), s(y)) -> s(s(+'(x, y)))
   *'(x, 0') -> 0'
   *'(0', x) -> 0'
   *'(s(x), s(y)) -> s(+'(*'(x, y), +'(x, y)))
   sum(nil) -> 0'
   sum(cons(x, l)) -> +'(x, sum(l))
   prod(nil) -> s(0')
   prod(cons(x, l)) -> *'(x, prod(l))

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

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

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


The TRS R consists of the following rules:

   +(x, 0) -> x
   +(0, x) -> x
   +(s(x), s(y)) -> s(s(+(x, y)))
   *(x, 0) -> 0
   *(0, x) -> 0
   *(s(x), s(y)) -> s(+(*(x, y), +(x, y)))
   sum(nil) -> 0
   sum(cons(x, l)) -> +(x, sum(l))
   prod(nil) -> s(0)
   prod(cons(x, l)) -> *(x, prod(l))

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

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

(6)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(z0, 0) -> c
   +'(0, z0) -> c1
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(z0, 0) -> c3
   *'(0, z0) -> c4
   *'(s(z0), s(z1)) -> c5(+'(*(z0, z1), +(z0, z1)), *'(z0, z1))
   *'(s(z0), s(z1)) -> c6(+'(*(z0, z1), +(z0, z1)), +'(z0, z1))
   SUM(nil) -> c7
   SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1))
   PROD(nil) -> c9
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
S tuples:
   +'(z0, 0) -> c
   +'(0, z0) -> c1
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(z0, 0) -> c3
   *'(0, z0) -> c4
   *'(s(z0), s(z1)) -> c5(+'(*(z0, z1), +(z0, z1)), *'(z0, z1))
   *'(s(z0), s(z1)) -> c6(+'(*(z0, z1), +(z0, z1)), +'(z0, z1))
   SUM(nil) -> c7
   SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1))
   PROD(nil) -> c9
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
K tuples:none
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, *'_2, SUM_1, PROD_1

Compound Symbols:   c, c1, c2_1, c3, c4, c5_2, c6_2, c7, c8_2, c9, c10_2


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

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

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


The TRS R consists of the following rules:

   +'(z0, 0) -> c
   +'(0, z0) -> c1
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(z0, 0) -> c3
   *'(0, z0) -> c4
   *'(s(z0), s(z1)) -> c5(+'(*(z0, z1), +(z0, z1)), *'(z0, z1))
   *'(s(z0), s(z1)) -> c6(+'(*(z0, z1), +(z0, z1)), +'(z0, z1))
   SUM(nil) -> c7
   SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1))
   PROD(nil) -> c9
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))

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

   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))

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

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

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


The TRS R consists of the following rules:

   +'(z0, 0') -> c
   +'(0', z0) -> c1
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(z0, 0') -> c3
   *'(0', z0) -> c4
   *'(s(z0), s(z1)) -> c5(+'(*'(z0, z1), +'(z0, z1)), *'(z0, z1))
   *'(s(z0), s(z1)) -> c6(+'(*'(z0, z1), +'(z0, z1)), +'(z0, z1))
   SUM(nil) -> c7
   SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1))
   PROD(nil) -> c9
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))

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

   +'(z0, 0') -> z0
   +'(0', z0) -> z0
   +'(s(z0), s(z1)) -> s(s(+'(z0, z1)))
   *'(z0, 0') -> 0'
   *'(0', z0) -> 0'
   *'(s(z0), s(z1)) -> s(+'(*'(z0, z1), +'(z0, z1)))
   sum(nil) -> 0'
   sum(cons(z0, z1)) -> +'(z0, sum(z1))
   prod(nil) -> s(0')
   prod(cons(z0, z1)) -> *'(z0, prod(z1))

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

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

(12)
Obligation:
Innermost TRS:
Rules:
+'(z0, 0') -> c
+'(0', z0) -> c1
+'(s(z0), s(z1)) -> c2(+'(z0, z1))
*'(z0, 0') -> c3
*'(0', z0) -> c4
*'(s(z0), s(z1)) -> c5(+'(*'(z0, z1), +'(z0, z1)), *'(z0, z1))
*'(s(z0), s(z1)) -> c6(+'(*'(z0, z1), +'(z0, z1)), +'(z0, z1))
SUM(nil) -> c7
SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1))
PROD(nil) -> c9
PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
+'(z0, 0') -> z0
+'(0', z0) -> z0
+'(s(z0), s(z1)) -> s(s(+'(z0, z1)))
*'(z0, 0') -> 0'
*'(0', z0) -> 0'
*'(s(z0), s(z1)) -> s(+'(*'(z0, z1), +'(z0, z1)))
sum(nil) -> 0'
sum(cons(z0, z1)) -> +'(z0, sum(z1))
prod(nil) -> s(0')
prod(cons(z0, z1)) -> *'(z0, prod(z1))

Types:
+' :: 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6
0' :: 0':c:c1:s:c2:c3:c4:c5:c6
c :: 0':c:c1:s:c2:c3:c4:c5:c6
c1 :: 0':c:c1:s:c2:c3:c4:c5:c6
s :: 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6
c2 :: 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6
*' :: 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6
c3 :: 0':c:c1:s:c2:c3:c4:c5:c6
c4 :: 0':c:c1:s:c2:c3:c4:c5:c6
c5 :: 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6
c6 :: 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6
SUM :: nil:cons -> c7:c8
nil :: nil:cons
c7 :: c7:c8
cons :: 0':c:c1:s:c2:c3:c4:c5:c6 -> nil:cons -> nil:cons
c8 :: 0':c:c1:s:c2:c3:c4:c5:c6 -> c7:c8 -> c7:c8
sum :: nil:cons -> 0':c:c1:s:c2:c3:c4:c5:c6
PROD :: nil:cons -> c9:c10
c9 :: c9:c10
c10 :: 0':c:c1:s:c2:c3:c4:c5:c6 -> c9:c10 -> c9:c10
prod :: nil:cons -> 0':c:c1:s:c2:c3:c4:c5:c6
hole_0':c:c1:s:c2:c3:c4:c5:c61_11 :: 0':c:c1:s:c2:c3:c4:c5:c6
hole_c7:c82_11 :: c7:c8
hole_nil:cons3_11 :: nil:cons
hole_c9:c104_11 :: c9:c10
gen_0':c:c1:s:c2:c3:c4:c5:c65_11 :: Nat -> 0':c:c1:s:c2:c3:c4:c5:c6
gen_c7:c86_11 :: Nat -> c7:c8
gen_nil:cons7_11 :: Nat -> nil:cons
gen_c9:c108_11 :: Nat -> c9:c10

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

(13) OrderProof (LOWER BOUND(ID))
Heuristically decided to analyse the following defined symbols:
+', *', SUM, sum, PROD, prod

They will be analysed ascendingly in the following order:
+' < *'
+' < SUM
+' < sum
*' < PROD
*' < prod
sum < SUM
prod < PROD

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

(14)
Obligation:
Innermost TRS:
Rules:
+'(z0, 0') -> c
+'(0', z0) -> c1
+'(s(z0), s(z1)) -> c2(+'(z0, z1))
*'(z0, 0') -> c3
*'(0', z0) -> c4
*'(s(z0), s(z1)) -> c5(+'(*'(z0, z1), +'(z0, z1)), *'(z0, z1))
*'(s(z0), s(z1)) -> c6(+'(*'(z0, z1), +'(z0, z1)), +'(z0, z1))
SUM(nil) -> c7
SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1))
PROD(nil) -> c9
PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
+'(z0, 0') -> z0
+'(0', z0) -> z0
+'(s(z0), s(z1)) -> s(s(+'(z0, z1)))
*'(z0, 0') -> 0'
*'(0', z0) -> 0'
*'(s(z0), s(z1)) -> s(+'(*'(z0, z1), +'(z0, z1)))
sum(nil) -> 0'
sum(cons(z0, z1)) -> +'(z0, sum(z1))
prod(nil) -> s(0')
prod(cons(z0, z1)) -> *'(z0, prod(z1))

Types:
+' :: 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6
0' :: 0':c:c1:s:c2:c3:c4:c5:c6
c :: 0':c:c1:s:c2:c3:c4:c5:c6
c1 :: 0':c:c1:s:c2:c3:c4:c5:c6
s :: 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6
c2 :: 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6
*' :: 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6
c3 :: 0':c:c1:s:c2:c3:c4:c5:c6
c4 :: 0':c:c1:s:c2:c3:c4:c5:c6
c5 :: 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6
c6 :: 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6
SUM :: nil:cons -> c7:c8
nil :: nil:cons
c7 :: c7:c8
cons :: 0':c:c1:s:c2:c3:c4:c5:c6 -> nil:cons -> nil:cons
c8 :: 0':c:c1:s:c2:c3:c4:c5:c6 -> c7:c8 -> c7:c8
sum :: nil:cons -> 0':c:c1:s:c2:c3:c4:c5:c6
PROD :: nil:cons -> c9:c10
c9 :: c9:c10
c10 :: 0':c:c1:s:c2:c3:c4:c5:c6 -> c9:c10 -> c9:c10
prod :: nil:cons -> 0':c:c1:s:c2:c3:c4:c5:c6
hole_0':c:c1:s:c2:c3:c4:c5:c61_11 :: 0':c:c1:s:c2:c3:c4:c5:c6
hole_c7:c82_11 :: c7:c8
hole_nil:cons3_11 :: nil:cons
hole_c9:c104_11 :: c9:c10
gen_0':c:c1:s:c2:c3:c4:c5:c65_11 :: Nat -> 0':c:c1:s:c2:c3:c4:c5:c6
gen_c7:c86_11 :: Nat -> c7:c8
gen_nil:cons7_11 :: Nat -> nil:cons
gen_c9:c108_11 :: Nat -> c9:c10


Generator Equations:
gen_0':c:c1:s:c2:c3:c4:c5:c65_11(0) <=> 0'
gen_0':c:c1:s:c2:c3:c4:c5:c65_11(+(x, 1)) <=> s(gen_0':c:c1:s:c2:c3:c4:c5:c65_11(x))
gen_c7:c86_11(0) <=> c7
gen_c7:c86_11(+(x, 1)) <=> c8(0', gen_c7:c86_11(x))
gen_nil:cons7_11(0) <=> nil
gen_nil:cons7_11(+(x, 1)) <=> cons(0', gen_nil:cons7_11(x))
gen_c9:c108_11(0) <=> c9
gen_c9:c108_11(+(x, 1)) <=> c10(0', gen_c9:c108_11(x))


The following defined symbols remain to be analysed:
+', *', SUM, sum, PROD, prod

They will be analysed ascendingly in the following order:
+' < *'
+' < SUM
+' < sum
*' < PROD
*' < prod
sum < SUM
prod < PROD

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

(15) RewriteLemmaProof (LOWER BOUND(ID))
Proved the following rewrite lemma:
+'(gen_0':c:c1:s:c2:c3:c4:c5:c65_11(+(1, n10_11)), gen_0':c:c1:s:c2:c3:c4:c5:c65_11(+(1, n10_11))) -> *9_11, rt in Omega(n10_11)

Induction Base:
+'(gen_0':c:c1:s:c2:c3:c4:c5:c65_11(+(1, 0)), gen_0':c:c1:s:c2:c3:c4:c5:c65_11(+(1, 0)))

Induction Step:
+'(gen_0':c:c1:s:c2:c3:c4:c5:c65_11(+(1, +(n10_11, 1))), gen_0':c:c1:s:c2:c3:c4:c5:c65_11(+(1, +(n10_11, 1)))) ->_R^Omega(1)
c2(+'(gen_0':c:c1:s:c2:c3:c4:c5:c65_11(+(1, n10_11)), gen_0':c:c1:s:c2:c3:c4:c5:c65_11(+(1, n10_11)))) ->_IH
c2(*9_11)

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

(16)
Complex Obligation (BEST)

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

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

Innermost TRS:
Rules:
+'(z0, 0') -> c
+'(0', z0) -> c1
+'(s(z0), s(z1)) -> c2(+'(z0, z1))
*'(z0, 0') -> c3
*'(0', z0) -> c4
*'(s(z0), s(z1)) -> c5(+'(*'(z0, z1), +'(z0, z1)), *'(z0, z1))
*'(s(z0), s(z1)) -> c6(+'(*'(z0, z1), +'(z0, z1)), +'(z0, z1))
SUM(nil) -> c7
SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1))
PROD(nil) -> c9
PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
+'(z0, 0') -> z0
+'(0', z0) -> z0
+'(s(z0), s(z1)) -> s(s(+'(z0, z1)))
*'(z0, 0') -> 0'
*'(0', z0) -> 0'
*'(s(z0), s(z1)) -> s(+'(*'(z0, z1), +'(z0, z1)))
sum(nil) -> 0'
sum(cons(z0, z1)) -> +'(z0, sum(z1))
prod(nil) -> s(0')
prod(cons(z0, z1)) -> *'(z0, prod(z1))

Types:
+' :: 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6
0' :: 0':c:c1:s:c2:c3:c4:c5:c6
c :: 0':c:c1:s:c2:c3:c4:c5:c6
c1 :: 0':c:c1:s:c2:c3:c4:c5:c6
s :: 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6
c2 :: 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6
*' :: 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6
c3 :: 0':c:c1:s:c2:c3:c4:c5:c6
c4 :: 0':c:c1:s:c2:c3:c4:c5:c6
c5 :: 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6
c6 :: 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6
SUM :: nil:cons -> c7:c8
nil :: nil:cons
c7 :: c7:c8
cons :: 0':c:c1:s:c2:c3:c4:c5:c6 -> nil:cons -> nil:cons
c8 :: 0':c:c1:s:c2:c3:c4:c5:c6 -> c7:c8 -> c7:c8
sum :: nil:cons -> 0':c:c1:s:c2:c3:c4:c5:c6
PROD :: nil:cons -> c9:c10
c9 :: c9:c10
c10 :: 0':c:c1:s:c2:c3:c4:c5:c6 -> c9:c10 -> c9:c10
prod :: nil:cons -> 0':c:c1:s:c2:c3:c4:c5:c6
hole_0':c:c1:s:c2:c3:c4:c5:c61_11 :: 0':c:c1:s:c2:c3:c4:c5:c6
hole_c7:c82_11 :: c7:c8
hole_nil:cons3_11 :: nil:cons
hole_c9:c104_11 :: c9:c10
gen_0':c:c1:s:c2:c3:c4:c5:c65_11 :: Nat -> 0':c:c1:s:c2:c3:c4:c5:c6
gen_c7:c86_11 :: Nat -> c7:c8
gen_nil:cons7_11 :: Nat -> nil:cons
gen_c9:c108_11 :: Nat -> c9:c10


Generator Equations:
gen_0':c:c1:s:c2:c3:c4:c5:c65_11(0) <=> 0'
gen_0':c:c1:s:c2:c3:c4:c5:c65_11(+(x, 1)) <=> s(gen_0':c:c1:s:c2:c3:c4:c5:c65_11(x))
gen_c7:c86_11(0) <=> c7
gen_c7:c86_11(+(x, 1)) <=> c8(0', gen_c7:c86_11(x))
gen_nil:cons7_11(0) <=> nil
gen_nil:cons7_11(+(x, 1)) <=> cons(0', gen_nil:cons7_11(x))
gen_c9:c108_11(0) <=> c9
gen_c9:c108_11(+(x, 1)) <=> c10(0', gen_c9:c108_11(x))


The following defined symbols remain to be analysed:
+', *', SUM, sum, PROD, prod

They will be analysed ascendingly in the following order:
+' < *'
+' < SUM
+' < sum
*' < PROD
*' < prod
sum < SUM
prod < PROD

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

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

(19)
BOUNDS(n^1, INF)

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

(20)
Obligation:
Innermost TRS:
Rules:
+'(z0, 0') -> c
+'(0', z0) -> c1
+'(s(z0), s(z1)) -> c2(+'(z0, z1))
*'(z0, 0') -> c3
*'(0', z0) -> c4
*'(s(z0), s(z1)) -> c5(+'(*'(z0, z1), +'(z0, z1)), *'(z0, z1))
*'(s(z0), s(z1)) -> c6(+'(*'(z0, z1), +'(z0, z1)), +'(z0, z1))
SUM(nil) -> c7
SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1))
PROD(nil) -> c9
PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
+'(z0, 0') -> z0
+'(0', z0) -> z0
+'(s(z0), s(z1)) -> s(s(+'(z0, z1)))
*'(z0, 0') -> 0'
*'(0', z0) -> 0'
*'(s(z0), s(z1)) -> s(+'(*'(z0, z1), +'(z0, z1)))
sum(nil) -> 0'
sum(cons(z0, z1)) -> +'(z0, sum(z1))
prod(nil) -> s(0')
prod(cons(z0, z1)) -> *'(z0, prod(z1))

Types:
+' :: 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6
0' :: 0':c:c1:s:c2:c3:c4:c5:c6
c :: 0':c:c1:s:c2:c3:c4:c5:c6
c1 :: 0':c:c1:s:c2:c3:c4:c5:c6
s :: 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6
c2 :: 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6
*' :: 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6
c3 :: 0':c:c1:s:c2:c3:c4:c5:c6
c4 :: 0':c:c1:s:c2:c3:c4:c5:c6
c5 :: 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6
c6 :: 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6 -> 0':c:c1:s:c2:c3:c4:c5:c6
SUM :: nil:cons -> c7:c8
nil :: nil:cons
c7 :: c7:c8
cons :: 0':c:c1:s:c2:c3:c4:c5:c6 -> nil:cons -> nil:cons
c8 :: 0':c:c1:s:c2:c3:c4:c5:c6 -> c7:c8 -> c7:c8
sum :: nil:cons -> 0':c:c1:s:c2:c3:c4:c5:c6
PROD :: nil:cons -> c9:c10
c9 :: c9:c10
c10 :: 0':c:c1:s:c2:c3:c4:c5:c6 -> c9:c10 -> c9:c10
prod :: nil:cons -> 0':c:c1:s:c2:c3:c4:c5:c6
hole_0':c:c1:s:c2:c3:c4:c5:c61_11 :: 0':c:c1:s:c2:c3:c4:c5:c6
hole_c7:c82_11 :: c7:c8
hole_nil:cons3_11 :: nil:cons
hole_c9:c104_11 :: c9:c10
gen_0':c:c1:s:c2:c3:c4:c5:c65_11 :: Nat -> 0':c:c1:s:c2:c3:c4:c5:c6
gen_c7:c86_11 :: Nat -> c7:c8
gen_nil:cons7_11 :: Nat -> nil:cons
gen_c9:c108_11 :: Nat -> c9:c10


Lemmas:
+'(gen_0':c:c1:s:c2:c3:c4:c5:c65_11(+(1, n10_11)), gen_0':c:c1:s:c2:c3:c4:c5:c65_11(+(1, n10_11))) -> *9_11, rt in Omega(n10_11)


Generator Equations:
gen_0':c:c1:s:c2:c3:c4:c5:c65_11(0) <=> 0'
gen_0':c:c1:s:c2:c3:c4:c5:c65_11(+(x, 1)) <=> s(gen_0':c:c1:s:c2:c3:c4:c5:c65_11(x))
gen_c7:c86_11(0) <=> c7
gen_c7:c86_11(+(x, 1)) <=> c8(0', gen_c7:c86_11(x))
gen_nil:cons7_11(0) <=> nil
gen_nil:cons7_11(+(x, 1)) <=> cons(0', gen_nil:cons7_11(x))
gen_c9:c108_11(0) <=> c9
gen_c9:c108_11(+(x, 1)) <=> c10(0', gen_c9:c108_11(x))


The following defined symbols remain to be analysed:
*', SUM, sum, PROD, prod

They will be analysed ascendingly in the following order:
*' < PROD
*' < prod
sum < SUM
prod < PROD

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

(21) RewriteLemmaProof (FINISHED)
Proved the following rewrite lemma:
*'(gen_0':c:c1:s:c2:c3:c4:c5:c65_11(+(1, n2980_11)), gen_0':c:c1:s:c2:c3:c4:c5:c65_11(+(1, n2980_11))) -> *9_11, rt in Omega(EXP)

Induction Base:
*'(gen_0':c:c1:s:c2:c3:c4:c5:c65_11(+(1, 0)), gen_0':c:c1:s:c2:c3:c4:c5:c65_11(+(1, 0)))

Induction Step:
*'(gen_0':c:c1:s:c2:c3:c4:c5:c65_11(+(1, +(n2980_11, 1))), gen_0':c:c1:s:c2:c3:c4:c5:c65_11(+(1, +(n2980_11, 1)))) ->_R^Omega(1)
c5(+'(*'(gen_0':c:c1:s:c2:c3:c4:c5:c65_11(+(1, n2980_11)), gen_0':c:c1:s:c2:c3:c4:c5:c65_11(+(1, n2980_11))), +'(gen_0':c:c1:s:c2:c3:c4:c5:c65_11(+(1, n2980_11)), gen_0':c:c1:s:c2:c3:c4:c5:c65_11(+(1, n2980_11)))), *'(gen_0':c:c1:s:c2:c3:c4:c5:c65_11(+(1, n2980_11)), gen_0':c:c1:s:c2:c3:c4:c5:c65_11(+(1, n2980_11)))) ->_IH
c5(+'(*9_11, +'(gen_0':c:c1:s:c2:c3:c4:c5:c65_11(+(1, n2980_11)), gen_0':c:c1:s:c2:c3:c4:c5:c65_11(+(1, n2980_11)))), *'(gen_0':c:c1:s:c2:c3:c4:c5:c65_11(+(1, n2980_11)), gen_0':c:c1:s:c2:c3:c4:c5:c65_11(+(1, n2980_11)))) ->_R^Omega(1)
c5(+'(*9_11, c2(+'(gen_0':c:c1:s:c2:c3:c4:c5:c65_11(n2980_11), gen_0':c:c1:s:c2:c3:c4:c5:c65_11(n2980_11)))), *'(gen_0':c:c1:s:c2:c3:c4:c5:c65_11(+(1, n2980_11)), gen_0':c:c1:s:c2:c3:c4:c5:c65_11(+(1, n2980_11)))) ->_IH
c5(+'(*9_11, c2(+'(gen_0':c:c1:s:c2:c3:c4:c5:c65_11(n2980_11), gen_0':c:c1:s:c2:c3:c4:c5:c65_11(n2980_11)))), *9_11)

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

(22)
BOUNDS(EXP, INF)

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

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

(24)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(z0, 0) -> c
   +'(0, z0) -> c1
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(z0, 0) -> c3
   *'(0, z0) -> c4
   *'(s(z0), s(z1)) -> c5(+'(*(z0, z1), +(z0, z1)), *'(z0, z1))
   *'(s(z0), s(z1)) -> c6(+'(*(z0, z1), +(z0, z1)), +'(z0, z1))
   SUM(nil) -> c7
   SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1))
   PROD(nil) -> c9
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
S tuples:
   +'(z0, 0) -> c
   +'(0, z0) -> c1
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(z0, 0) -> c3
   *'(0, z0) -> c4
   *'(s(z0), s(z1)) -> c5(+'(*(z0, z1), +(z0, z1)), *'(z0, z1))
   *'(s(z0), s(z1)) -> c6(+'(*(z0, z1), +(z0, z1)), +'(z0, z1))
   SUM(nil) -> c7
   SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1))
   PROD(nil) -> c9
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
K tuples:none
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, *'_2, SUM_1, PROD_1

Compound Symbols:   c, c1, c2_1, c3, c4, c5_2, c6_2, c7, c8_2, c9, c10_2


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

(25) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 6 trailing nodes:
   *'(0, z0) -> c4
   +'(z0, 0) -> c
   PROD(nil) -> c9
   *'(z0, 0) -> c3
   +'(0, z0) -> c1
   SUM(nil) -> c7

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

(26)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c5(+'(*(z0, z1), +(z0, z1)), *'(z0, z1))
   *'(s(z0), s(z1)) -> c6(+'(*(z0, z1), +(z0, z1)), +'(z0, z1))
   SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1))
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
S tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c5(+'(*(z0, z1), +(z0, z1)), *'(z0, z1))
   *'(s(z0), s(z1)) -> c6(+'(*(z0, z1), +(z0, z1)), +'(z0, z1))
   SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1))
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
K tuples:none
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, *'_2, SUM_1, PROD_1

Compound Symbols:   c2_1, c5_2, c6_2, c8_2, c10_2


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

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

(28)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c5(+'(*(z0, z1), +(z0, z1)), *'(z0, z1))
   SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1))
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
   *'(s(z0), s(z1)) -> c(+'(*(z0, z1), +(z0, z1)))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
S tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c5(+'(*(z0, z1), +(z0, z1)), *'(z0, z1))
   SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1))
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
   *'(s(z0), s(z1)) -> c(+'(*(z0, z1), +(z0, z1)))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
K tuples:none
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, *'_2, SUM_1, PROD_1

Compound Symbols:   c2_1, c5_2, c8_2, c10_2, c_1


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

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

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

   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c5(+'(*(z0, z1), +(z0, z1)), *'(z0, z1))
   SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1))
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
   *'(s(z0), s(z1)) -> c(+'(*(z0, z1), +(z0, z1)))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))

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

   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))

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

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

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

   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c5(+'(*(z0, z1), +(z0, z1)), *'(z0, z1))
   SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1))
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
   *'(s(z0), s(z1)) -> c(+'(*(z0, z1), +(z0, z1)))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))

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

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

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

   +'(s(z0), s(z1)) -> c2(+'(z0, z1)) [1]
   *'(s(z0), s(z1)) -> c5(+'(*(z0, z1), +(z0, z1)), *'(z0, z1)) [1]
   SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1)) [1]
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1)) [1]
   *'(s(z0), s(z1)) -> c(+'(*(z0, z1), +(z0, z1))) [1]
   *'(s(z0), s(z1)) -> c(+'(z0, z1)) [1]
   +(z0, 0) -> z0 [0]
   +(0, z0) -> z0 [0]
   +(s(z0), s(z1)) -> s(s(+(z0, z1))) [0]
   *(z0, 0) -> 0 [0]
   *(0, z0) -> 0 [0]
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1))) [0]
   sum(nil) -> 0 [0]
   sum(cons(z0, z1)) -> +(z0, sum(z1)) [0]
   prod(nil) -> s(0) [0]
   prod(cons(z0, z1)) -> *(z0, prod(z1)) [0]

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

(35) CpxWeightedTrsRenamingProof (BOTH BOUNDS(ID, ID))
Renamed defined symbols to avoid conflicts with arithmetic symbols:

* => times
+ => plus

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

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

   +'(s(z0), s(z1)) -> c2(+'(z0, z1)) [1]
   *'(s(z0), s(z1)) -> c5(+'(times(z0, z1), plus(z0, z1)), *'(z0, z1)) [1]
   SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1)) [1]
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1)) [1]
   *'(s(z0), s(z1)) -> c(+'(times(z0, z1), plus(z0, z1))) [1]
   *'(s(z0), s(z1)) -> c(+'(z0, z1)) [1]
   plus(z0, 0) -> z0 [0]
   plus(0, z0) -> z0 [0]
   plus(s(z0), s(z1)) -> s(s(plus(z0, z1))) [0]
   times(z0, 0) -> 0 [0]
   times(0, z0) -> 0 [0]
   times(s(z0), s(z1)) -> s(plus(times(z0, z1), plus(z0, z1))) [0]
   sum(nil) -> 0 [0]
   sum(cons(z0, z1)) -> plus(z0, sum(z1)) [0]
   prod(nil) -> s(0) [0]
   prod(cons(z0, z1)) -> times(z0, prod(z1)) [0]

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

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

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

   +'(s(z0), s(z1)) -> c2(+'(z0, z1)) [1]
   *'(s(z0), s(z1)) -> c5(+'(times(z0, z1), plus(z0, z1)), *'(z0, z1)) [1]
   SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1)) [1]
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1)) [1]
   *'(s(z0), s(z1)) -> c(+'(times(z0, z1), plus(z0, z1))) [1]
   *'(s(z0), s(z1)) -> c(+'(z0, z1)) [1]
   plus(z0, 0) -> z0 [0]
   plus(0, z0) -> z0 [0]
   plus(s(z0), s(z1)) -> s(s(plus(z0, z1))) [0]
   times(z0, 0) -> 0 [0]
   times(0, z0) -> 0 [0]
   times(s(z0), s(z1)) -> s(plus(times(z0, z1), plus(z0, z1))) [0]
   sum(nil) -> 0 [0]
   sum(cons(z0, z1)) -> plus(z0, sum(z1)) [0]
   prod(nil) -> s(0) [0]
   prod(cons(z0, z1)) -> times(z0, prod(z1)) [0]

The TRS has the following type information:
+' :: s:0 -> s:0 -> c2
s :: s:0 -> s:0
c2 :: c2 -> c2
*' :: s:0 -> s:0 -> c5:c
c5 :: c2 -> c5:c -> c5:c
times :: s:0 -> s:0 -> s:0
plus :: s:0 -> s:0 -> s:0
SUM :: cons:nil -> c8
cons :: s:0 -> cons:nil -> cons:nil
c8 :: c2 -> c8 -> c8
sum :: cons:nil -> s:0
PROD :: cons:nil -> c10
c10 :: c5:c -> c10 -> c10
prod :: cons:nil -> s:0
c :: c2 -> c5:c
0 :: s:0
nil :: cons:nil

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

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

   +'_2
   *'_2
   SUM_1
   PROD_1

(c) The following functions are completely defined:

   plus_2
   times_2
   sum_1
   prod_1

Due to the following rules being added:

   plus(v0, v1) -> 0 [0]
   times(v0, v1) -> 0 [0]
   sum(v0) -> 0 [0]
   prod(v0) -> 0 [0]

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

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

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

   +'(s(z0), s(z1)) -> c2(+'(z0, z1)) [1]
   *'(s(z0), s(z1)) -> c5(+'(times(z0, z1), plus(z0, z1)), *'(z0, z1)) [1]
   SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1)) [1]
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1)) [1]
   *'(s(z0), s(z1)) -> c(+'(times(z0, z1), plus(z0, z1))) [1]
   *'(s(z0), s(z1)) -> c(+'(z0, z1)) [1]
   plus(z0, 0) -> z0 [0]
   plus(0, z0) -> z0 [0]
   plus(s(z0), s(z1)) -> s(s(plus(z0, z1))) [0]
   times(z0, 0) -> 0 [0]
   times(0, z0) -> 0 [0]
   times(s(z0), s(z1)) -> s(plus(times(z0, z1), plus(z0, z1))) [0]
   sum(nil) -> 0 [0]
   sum(cons(z0, z1)) -> plus(z0, sum(z1)) [0]
   prod(nil) -> s(0) [0]
   prod(cons(z0, z1)) -> times(z0, prod(z1)) [0]
   plus(v0, v1) -> 0 [0]
   times(v0, v1) -> 0 [0]
   sum(v0) -> 0 [0]
   prod(v0) -> 0 [0]

The TRS has the following type information:
+' :: s:0 -> s:0 -> c2
s :: s:0 -> s:0
c2 :: c2 -> c2
*' :: s:0 -> s:0 -> c5:c
c5 :: c2 -> c5:c -> c5:c
times :: s:0 -> s:0 -> s:0
plus :: s:0 -> s:0 -> s:0
SUM :: cons:nil -> c8
cons :: s:0 -> cons:nil -> cons:nil
c8 :: c2 -> c8 -> c8
sum :: cons:nil -> s:0
PROD :: cons:nil -> c10
c10 :: c5:c -> c10 -> c10
prod :: cons:nil -> s:0
c :: c2 -> c5:c
0 :: s:0
nil :: cons:nil
const :: c2
const1 :: c5:c
const2 :: c8
const3 :: c10

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

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

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

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

   +'(s(z0), s(z1)) -> c2(+'(z0, z1)) [1]
   *'(s(z0), s(0)) -> c5(+'(0, z0), *'(z0, 0)) [1]
   *'(s(0), s(0)) -> c5(+'(0, 0), *'(0, 0)) [1]
   *'(s(z0), s(0)) -> c5(+'(0, 0), *'(z0, 0)) [1]
   *'(s(0), s(0)) -> c5(+'(0, 0), *'(0, 0)) [1]
   *'(s(0), s(z1)) -> c5(+'(0, z1), *'(0, z1)) [1]
   *'(s(0), s(z1)) -> c5(+'(0, 0), *'(0, z1)) [1]
   *'(s(s(z0')), s(s(z1'))) -> c5(+'(s(plus(times(z0', z1'), plus(z0', z1'))), s(s(plus(z0', z1')))), *'(s(z0'), s(z1'))) [1]
   *'(s(s(z0')), s(s(z1'))) -> c5(+'(s(plus(times(z0', z1'), plus(z0', z1'))), 0), *'(s(z0'), s(z1'))) [1]
   *'(s(z0), s(0)) -> c5(+'(0, z0), *'(z0, 0)) [1]
   *'(s(0), s(z1)) -> c5(+'(0, z1), *'(0, z1)) [1]
   *'(s(s(z0'')), s(s(z1''))) -> c5(+'(0, s(s(plus(z0'', z1'')))), *'(s(z0''), s(z1''))) [1]
   *'(s(z0), s(z1)) -> c5(+'(0, 0), *'(z0, z1)) [1]
   SUM(cons(z0, nil)) -> c8(+'(z0, 0), SUM(nil)) [1]
   SUM(cons(z0, cons(z01, z11))) -> c8(+'(z0, plus(z01, sum(z11))), SUM(cons(z01, z11))) [1]
   SUM(cons(z0, z1)) -> c8(+'(z0, 0), SUM(z1)) [1]
   PROD(cons(z0, nil)) -> c10(*'(z0, s(0)), PROD(nil)) [1]
   PROD(cons(z0, cons(z02, z12))) -> c10(*'(z0, times(z02, prod(z12))), PROD(cons(z02, z12))) [1]
   PROD(cons(z0, z1)) -> c10(*'(z0, 0), PROD(z1)) [1]
   *'(s(z0), s(0)) -> c(+'(0, z0)) [1]
   *'(s(0), s(0)) -> c(+'(0, 0)) [1]
   *'(s(z0), s(0)) -> c(+'(0, 0)) [1]
   *'(s(0), s(0)) -> c(+'(0, 0)) [1]
   *'(s(0), s(z1)) -> c(+'(0, z1)) [1]
   *'(s(0), s(z1)) -> c(+'(0, 0)) [1]
   *'(s(s(z03)), s(s(z13))) -> c(+'(s(plus(times(z03, z13), plus(z03, z13))), s(s(plus(z03, z13))))) [1]
   *'(s(s(z03)), s(s(z13))) -> c(+'(s(plus(times(z03, z13), plus(z03, z13))), 0)) [1]
   *'(s(z0), s(0)) -> c(+'(0, z0)) [1]
   *'(s(0), s(z1)) -> c(+'(0, z1)) [1]
   *'(s(s(z04)), s(s(z14))) -> c(+'(0, s(s(plus(z04, z14))))) [1]
   *'(s(z0), s(z1)) -> c(+'(0, 0)) [1]
   *'(s(z0), s(z1)) -> c(+'(z0, z1)) [1]
   plus(z0, 0) -> z0 [0]
   plus(0, z0) -> z0 [0]
   plus(s(z0), s(z1)) -> s(s(plus(z0, z1))) [0]
   times(z0, 0) -> 0 [0]
   times(0, z0) -> 0 [0]
   times(s(z0), s(0)) -> s(plus(0, z0)) [0]
   times(s(0), s(0)) -> s(plus(0, 0)) [0]
   times(s(z0), s(0)) -> s(plus(0, 0)) [0]
   times(s(0), s(0)) -> s(plus(0, 0)) [0]
   times(s(0), s(z1)) -> s(plus(0, z1)) [0]
   times(s(0), s(z1)) -> s(plus(0, 0)) [0]
   times(s(s(z05)), s(s(z15))) -> s(plus(s(plus(times(z05, z15), plus(z05, z15))), s(s(plus(z05, z15))))) [0]
   times(s(s(z05)), s(s(z15))) -> s(plus(s(plus(times(z05, z15), plus(z05, z15))), 0)) [0]
   times(s(z0), s(0)) -> s(plus(0, z0)) [0]
   times(s(0), s(z1)) -> s(plus(0, z1)) [0]
   times(s(s(z06)), s(s(z16))) -> s(plus(0, s(s(plus(z06, z16))))) [0]
   times(s(z0), s(z1)) -> s(plus(0, 0)) [0]
   sum(nil) -> 0 [0]
   sum(cons(z0, nil)) -> plus(z0, 0) [0]
   sum(cons(z0, cons(z07, z17))) -> plus(z0, plus(z07, sum(z17))) [0]
   sum(cons(z0, z1)) -> plus(z0, 0) [0]
   prod(nil) -> s(0) [0]
   prod(cons(z0, nil)) -> times(z0, s(0)) [0]
   prod(cons(z0, cons(z08, z18))) -> times(z0, times(z08, prod(z18))) [0]
   prod(cons(z0, z1)) -> times(z0, 0) [0]
   plus(v0, v1) -> 0 [0]
   times(v0, v1) -> 0 [0]
   sum(v0) -> 0 [0]
   prod(v0) -> 0 [0]

The TRS has the following type information:
+' :: s:0 -> s:0 -> c2
s :: s:0 -> s:0
c2 :: c2 -> c2
*' :: s:0 -> s:0 -> c5:c
c5 :: c2 -> c5:c -> c5:c
times :: s:0 -> s:0 -> s:0
plus :: s:0 -> s:0 -> s:0
SUM :: cons:nil -> c8
cons :: s:0 -> cons:nil -> cons:nil
c8 :: c2 -> c8 -> c8
sum :: cons:nil -> s:0
PROD :: cons:nil -> c10
c10 :: c5:c -> c10 -> c10
prod :: cons:nil -> s:0
c :: c2 -> c5:c
0 :: s:0
nil :: cons:nil
const :: c2
const1 :: c5:c
const2 :: c8
const3 :: c10

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

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

   0 => 0
   nil => 0
   const => 0
   const1 => 0
   const2 => 0
   const3 => 0

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

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

   *'(z, z') -{ 1 }-> 1 + +'(z0, z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   *'(z, z') -{ 1 }-> 1 + +'(0, z0) :|: z = 1 + z0, z' = 1 + 0, z0 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, z1) :|: z1 >= 0, z = 1 + 0, z' = 1 + z1
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) :|: z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) :|: z = 1 + z0, z' = 1 + 0, z0 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) :|: z1 >= 0, z = 1 + 0, z' = 1 + z1
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   *'(z, z') -{ 1 }-> 1 + +'(0, 1 + (1 + plus(z04, z14))) :|: z04 >= 0, z' = 1 + (1 + z14), z = 1 + (1 + z04), z14 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z03, z13), plus(z03, z13)), 0) :|: z = 1 + (1 + z03), z' = 1 + (1 + z13), z03 >= 0, z13 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z03, z13), plus(z03, z13)), 1 + (1 + plus(z03, z13))) :|: z = 1 + (1 + z03), z' = 1 + (1 + z13), z03 >= 0, z13 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, z0) + *'(z0, 0) :|: z = 1 + z0, z' = 1 + 0, z0 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, z1) + *'(0, z1) :|: z1 >= 0, z = 1 + 0, z' = 1 + z1
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) + *'(z0, z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) + *'(z0, 0) :|: z = 1 + z0, z' = 1 + 0, z0 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) + *'(0, z1) :|: z1 >= 0, z = 1 + 0, z' = 1 + z1
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) + *'(0, 0) :|: z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 1 + (1 + plus(z0'', z1''))) + *'(1 + z0'', 1 + z1'') :|: z' = 1 + (1 + z1''), z = 1 + (1 + z0''), z0'' >= 0, z1'' >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z0', z1'), plus(z0', z1')), 0) + *'(1 + z0', 1 + z1') :|: z' = 1 + (1 + z1'), z = 1 + (1 + z0'), z0' >= 0, z1' >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z0', z1'), plus(z0', z1')), 1 + (1 + plus(z0', z1'))) + *'(1 + z0', 1 + z1') :|: z' = 1 + (1 + z1'), z = 1 + (1 + z0'), z0' >= 0, z1' >= 0
   +'(z, z') -{ 1 }-> 1 + +'(z0, z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   PROD(z) -{ 1 }-> 1 + *'(z0, times(z02, prod(z12))) + PROD(1 + z02 + z12) :|: z = 1 + z0 + (1 + z02 + z12), z02 >= 0, z0 >= 0, z12 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, 0) + PROD(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   PROD(z) -{ 1 }-> 1 + *'(z0, 1 + 0) + PROD(0) :|: z0 >= 0, z = 1 + z0 + 0
   SUM(z) -{ 1 }-> 1 + +'(z0, plus(z01, sum(z11))) + SUM(1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z0 >= 0, z = 1 + z0 + (1 + z01 + z11)
   SUM(z) -{ 1 }-> 1 + +'(z0, 0) + SUM(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 1 }-> 1 + +'(z0, 0) + SUM(0) :|: z0 >= 0, z = 1 + z0 + 0
   plus(z, z') -{ 0 }-> z0 :|: z = z0, z0 >= 0, z' = 0
   plus(z, z') -{ 0 }-> z0 :|: z0 >= 0, z = 0, z' = z0
   plus(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   plus(z, z') -{ 0 }-> 1 + (1 + plus(z0, z1)) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   prod(z) -{ 0 }-> times(z0, times(z08, prod(z18))) :|: z08 >= 0, z18 >= 0, z0 >= 0, z = 1 + z0 + (1 + z08 + z18)
   prod(z) -{ 0 }-> times(z0, 0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   prod(z) -{ 0 }-> times(z0, 1 + 0) :|: z0 >= 0, z = 1 + z0 + 0
   prod(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   prod(z) -{ 0 }-> 1 + 0 :|: z = 0
   sum(z) -{ 0 }-> plus(z0, plus(z07, sum(z17))) :|: z = 1 + z0 + (1 + z07 + z17), z07 >= 0, z17 >= 0, z0 >= 0
   sum(z) -{ 0 }-> plus(z0, 0) :|: z0 >= 0, z = 1 + z0 + 0
   sum(z) -{ 0 }-> plus(z0, 0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   sum(z) -{ 0 }-> 0 :|: z = 0
   sum(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   times(z, z') -{ 0 }-> 0 :|: z = z0, z0 >= 0, z' = 0
   times(z, z') -{ 0 }-> 0 :|: z0 >= 0, z = 0, z' = z0
   times(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   times(z, z') -{ 0 }-> 1 + plus(0, z0) :|: z = 1 + z0, z' = 1 + 0, z0 >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, z1) :|: z1 >= 0, z = 1 + 0, z' = 1 + z1
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z = 1 + z0, z' = 1 + 0, z0 >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z1 >= 0, z = 1 + 0, z' = 1 + z1
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   times(z, z') -{ 0 }-> 1 + plus(0, 1 + (1 + plus(z06, z16))) :|: z' = 1 + (1 + z16), z06 >= 0, z16 >= 0, z = 1 + (1 + z06)
   times(z, z') -{ 0 }-> 1 + plus(1 + plus(times(z05, z15), plus(z05, z15)), 0) :|: z' = 1 + (1 + z15), z15 >= 0, z05 >= 0, z = 1 + (1 + z05)
   times(z, z') -{ 0 }-> 1 + plus(1 + plus(times(z05, z15), plus(z05, z15)), 1 + (1 + plus(z05, z15))) :|: z' = 1 + (1 + z15), z15 >= 0, z05 >= 0, z = 1 + (1 + z05)


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

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

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

   *'(z, z') -{ 1 }-> 1 + +'(0, 0) :|: z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) :|: z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) :|: z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) :|: z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, z - 1) :|: z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, z' - 1) :|: z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 1 + (1 + plus(z - 2, z' - 2))) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 0) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 1 + (1 + plus(z - 2, z' - 2))) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) + *'(0, 0) :|: z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) + *'(0, z' - 1) :|: z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) + *'(z - 1, 0) :|: z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) + *'(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, z - 1) + *'(z - 1, 0) :|: z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, z' - 1) + *'(0, z' - 1) :|: z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 1 + (1 + plus(z - 2, z' - 2))) + *'(1 + (z - 2), 1 + (z' - 2)) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 0) + *'(1 + (z - 2), 1 + (z' - 2)) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 1 + (1 + plus(z - 2, z' - 2))) + *'(1 + (z - 2), 1 + (z' - 2)) :|: z - 2 >= 0, z' - 2 >= 0
   +'(z, z') -{ 1 }-> 1 + +'(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, times(z02, prod(z12))) + PROD(1 + z02 + z12) :|: z = 1 + z0 + (1 + z02 + z12), z02 >= 0, z0 >= 0, z12 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, 0) + PROD(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   PROD(z) -{ 1 }-> 1 + *'(z - 1, 1 + 0) + PROD(0) :|: z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + +'(z0, plus(z01, sum(z11))) + SUM(1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z0 >= 0, z = 1 + z0 + (1 + z01 + z11)
   SUM(z) -{ 1 }-> 1 + +'(z0, 0) + SUM(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 1 }-> 1 + +'(z - 1, 0) + SUM(0) :|: z - 1 >= 0
   plus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + (1 + plus(z - 1, z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   prod(z) -{ 0 }-> times(z0, times(z08, prod(z18))) :|: z08 >= 0, z18 >= 0, z0 >= 0, z = 1 + z0 + (1 + z08 + z18)
   prod(z) -{ 0 }-> times(z0, 0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   prod(z) -{ 0 }-> times(z - 1, 1 + 0) :|: z - 1 >= 0
   prod(z) -{ 0 }-> 0 :|: z >= 0
   prod(z) -{ 0 }-> 1 + 0 :|: z = 0
   sum(z) -{ 0 }-> plus(z0, plus(z07, sum(z17))) :|: z = 1 + z0 + (1 + z07 + z17), z07 >= 0, z17 >= 0, z0 >= 0
   sum(z) -{ 0 }-> plus(z0, 0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   sum(z) -{ 0 }-> plus(z - 1, 0) :|: z - 1 >= 0
   sum(z) -{ 0 }-> 0 :|: z = 0
   sum(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 0 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z' - 1 >= 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, z - 1) :|: z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, z' - 1) :|: z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + plus(0, 1 + (1 + plus(z - 2, z' - 2))) :|: z - 2 >= 0, z' - 2 >= 0
   times(z, z') -{ 0 }-> 1 + plus(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 0) :|: z' - 2 >= 0, z - 2 >= 0
   times(z, z') -{ 0 }-> 1 + plus(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 1 + (1 + plus(z - 2, z' - 2))) :|: z' - 2 >= 0, z - 2 >= 0


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

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

   { +' }
   { plus }
   { times }
   { sum }
   { prod }
   { *' }
   { SUM }
   { PROD }

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

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

   *'(z, z') -{ 1 }-> 1 + +'(0, 0) :|: z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) :|: z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) :|: z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) :|: z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, z - 1) :|: z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, z' - 1) :|: z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 1 + (1 + plus(z - 2, z' - 2))) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 0) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 1 + (1 + plus(z - 2, z' - 2))) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) + *'(0, 0) :|: z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) + *'(0, z' - 1) :|: z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) + *'(z - 1, 0) :|: z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) + *'(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, z - 1) + *'(z - 1, 0) :|: z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, z' - 1) + *'(0, z' - 1) :|: z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 1 + (1 + plus(z - 2, z' - 2))) + *'(1 + (z - 2), 1 + (z' - 2)) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 0) + *'(1 + (z - 2), 1 + (z' - 2)) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 1 + (1 + plus(z - 2, z' - 2))) + *'(1 + (z - 2), 1 + (z' - 2)) :|: z - 2 >= 0, z' - 2 >= 0
   +'(z, z') -{ 1 }-> 1 + +'(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, times(z02, prod(z12))) + PROD(1 + z02 + z12) :|: z = 1 + z0 + (1 + z02 + z12), z02 >= 0, z0 >= 0, z12 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, 0) + PROD(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   PROD(z) -{ 1 }-> 1 + *'(z - 1, 1 + 0) + PROD(0) :|: z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + +'(z0, plus(z01, sum(z11))) + SUM(1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z0 >= 0, z = 1 + z0 + (1 + z01 + z11)
   SUM(z) -{ 1 }-> 1 + +'(z0, 0) + SUM(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 1 }-> 1 + +'(z - 1, 0) + SUM(0) :|: z - 1 >= 0
   plus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + (1 + plus(z - 1, z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   prod(z) -{ 0 }-> times(z0, times(z08, prod(z18))) :|: z08 >= 0, z18 >= 0, z0 >= 0, z = 1 + z0 + (1 + z08 + z18)
   prod(z) -{ 0 }-> times(z0, 0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   prod(z) -{ 0 }-> times(z - 1, 1 + 0) :|: z - 1 >= 0
   prod(z) -{ 0 }-> 0 :|: z >= 0
   prod(z) -{ 0 }-> 1 + 0 :|: z = 0
   sum(z) -{ 0 }-> plus(z0, plus(z07, sum(z17))) :|: z = 1 + z0 + (1 + z07 + z17), z07 >= 0, z17 >= 0, z0 >= 0
   sum(z) -{ 0 }-> plus(z0, 0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   sum(z) -{ 0 }-> plus(z - 1, 0) :|: z - 1 >= 0
   sum(z) -{ 0 }-> 0 :|: z = 0
   sum(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 0 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z' - 1 >= 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, z - 1) :|: z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, z' - 1) :|: z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + plus(0, 1 + (1 + plus(z - 2, z' - 2))) :|: z - 2 >= 0, z' - 2 >= 0
   times(z, z') -{ 0 }-> 1 + plus(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 0) :|: z' - 2 >= 0, z - 2 >= 0
   times(z, z') -{ 0 }-> 1 + plus(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 1 + (1 + plus(z - 2, z' - 2))) :|: z' - 2 >= 0, z - 2 >= 0

Function symbols to be analyzed: {+'}, {plus}, {times}, {sum}, {prod}, {*'}, {SUM}, {PROD}

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

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

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

   *'(z, z') -{ 1 }-> 1 + +'(0, 0) :|: z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) :|: z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) :|: z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) :|: z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, z - 1) :|: z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, z' - 1) :|: z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 1 + (1 + plus(z - 2, z' - 2))) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 0) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 1 + (1 + plus(z - 2, z' - 2))) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) + *'(0, 0) :|: z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) + *'(0, z' - 1) :|: z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) + *'(z - 1, 0) :|: z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) + *'(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, z - 1) + *'(z - 1, 0) :|: z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, z' - 1) + *'(0, z' - 1) :|: z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 1 + (1 + plus(z - 2, z' - 2))) + *'(1 + (z - 2), 1 + (z' - 2)) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 0) + *'(1 + (z - 2), 1 + (z' - 2)) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 1 + (1 + plus(z - 2, z' - 2))) + *'(1 + (z - 2), 1 + (z' - 2)) :|: z - 2 >= 0, z' - 2 >= 0
   +'(z, z') -{ 1 }-> 1 + +'(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, times(z02, prod(z12))) + PROD(1 + z02 + z12) :|: z = 1 + z0 + (1 + z02 + z12), z02 >= 0, z0 >= 0, z12 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, 0) + PROD(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   PROD(z) -{ 1 }-> 1 + *'(z - 1, 1 + 0) + PROD(0) :|: z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + +'(z0, plus(z01, sum(z11))) + SUM(1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z0 >= 0, z = 1 + z0 + (1 + z01 + z11)
   SUM(z) -{ 1 }-> 1 + +'(z0, 0) + SUM(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 1 }-> 1 + +'(z - 1, 0) + SUM(0) :|: z - 1 >= 0
   plus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + (1 + plus(z - 1, z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   prod(z) -{ 0 }-> times(z0, times(z08, prod(z18))) :|: z08 >= 0, z18 >= 0, z0 >= 0, z = 1 + z0 + (1 + z08 + z18)
   prod(z) -{ 0 }-> times(z0, 0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   prod(z) -{ 0 }-> times(z - 1, 1 + 0) :|: z - 1 >= 0
   prod(z) -{ 0 }-> 0 :|: z >= 0
   prod(z) -{ 0 }-> 1 + 0 :|: z = 0
   sum(z) -{ 0 }-> plus(z0, plus(z07, sum(z17))) :|: z = 1 + z0 + (1 + z07 + z17), z07 >= 0, z17 >= 0, z0 >= 0
   sum(z) -{ 0 }-> plus(z0, 0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   sum(z) -{ 0 }-> plus(z - 1, 0) :|: z - 1 >= 0
   sum(z) -{ 0 }-> 0 :|: z = 0
   sum(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 0 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z' - 1 >= 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, z - 1) :|: z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, z' - 1) :|: z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + plus(0, 1 + (1 + plus(z - 2, z' - 2))) :|: z - 2 >= 0, z' - 2 >= 0
   times(z, z') -{ 0 }-> 1 + plus(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 0) :|: z' - 2 >= 0, z - 2 >= 0
   times(z, z') -{ 0 }-> 1 + plus(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 1 + (1 + plus(z - 2, z' - 2))) :|: z' - 2 >= 0, z - 2 >= 0

Function symbols to be analyzed: {+'}, {plus}, {times}, {sum}, {prod}, {*'}, {SUM}, {PROD}

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

(51) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   *'(z, z') -{ 1 }-> 1 + +'(0, 0) :|: z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) :|: z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) :|: z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) :|: z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, z - 1) :|: z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, z' - 1) :|: z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 1 + (1 + plus(z - 2, z' - 2))) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 0) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 1 + (1 + plus(z - 2, z' - 2))) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) + *'(0, 0) :|: z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) + *'(0, z' - 1) :|: z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) + *'(z - 1, 0) :|: z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) + *'(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, z - 1) + *'(z - 1, 0) :|: z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, z' - 1) + *'(0, z' - 1) :|: z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 1 + (1 + plus(z - 2, z' - 2))) + *'(1 + (z - 2), 1 + (z' - 2)) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 0) + *'(1 + (z - 2), 1 + (z' - 2)) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 1 + (1 + plus(z - 2, z' - 2))) + *'(1 + (z - 2), 1 + (z' - 2)) :|: z - 2 >= 0, z' - 2 >= 0
   +'(z, z') -{ 1 }-> 1 + +'(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, times(z02, prod(z12))) + PROD(1 + z02 + z12) :|: z = 1 + z0 + (1 + z02 + z12), z02 >= 0, z0 >= 0, z12 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, 0) + PROD(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   PROD(z) -{ 1 }-> 1 + *'(z - 1, 1 + 0) + PROD(0) :|: z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + +'(z0, plus(z01, sum(z11))) + SUM(1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z0 >= 0, z = 1 + z0 + (1 + z01 + z11)
   SUM(z) -{ 1 }-> 1 + +'(z0, 0) + SUM(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 1 }-> 1 + +'(z - 1, 0) + SUM(0) :|: z - 1 >= 0
   plus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + (1 + plus(z - 1, z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   prod(z) -{ 0 }-> times(z0, times(z08, prod(z18))) :|: z08 >= 0, z18 >= 0, z0 >= 0, z = 1 + z0 + (1 + z08 + z18)
   prod(z) -{ 0 }-> times(z0, 0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   prod(z) -{ 0 }-> times(z - 1, 1 + 0) :|: z - 1 >= 0
   prod(z) -{ 0 }-> 0 :|: z >= 0
   prod(z) -{ 0 }-> 1 + 0 :|: z = 0
   sum(z) -{ 0 }-> plus(z0, plus(z07, sum(z17))) :|: z = 1 + z0 + (1 + z07 + z17), z07 >= 0, z17 >= 0, z0 >= 0
   sum(z) -{ 0 }-> plus(z0, 0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   sum(z) -{ 0 }-> plus(z - 1, 0) :|: z - 1 >= 0
   sum(z) -{ 0 }-> 0 :|: z = 0
   sum(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 0 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z' - 1 >= 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, z - 1) :|: z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, z' - 1) :|: z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + plus(0, 1 + (1 + plus(z - 2, z' - 2))) :|: z - 2 >= 0, z' - 2 >= 0
   times(z, z') -{ 0 }-> 1 + plus(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 0) :|: z' - 2 >= 0, z - 2 >= 0
   times(z, z') -{ 0 }-> 1 + plus(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 1 + (1 + plus(z - 2, z' - 2))) :|: z' - 2 >= 0, z - 2 >= 0

Function symbols to be analyzed: {+'}, {plus}, {times}, {sum}, {prod}, {*'}, {SUM}, {PROD}
Previous analysis results are:
  +': runtime: ?, size: O(1) [0]

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

(53) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   *'(z, z') -{ 1 }-> 1 + +'(0, 0) :|: z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) :|: z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) :|: z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) :|: z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, z - 1) :|: z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, z' - 1) :|: z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 1 + (1 + plus(z - 2, z' - 2))) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 0) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 1 + (1 + plus(z - 2, z' - 2))) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) + *'(0, 0) :|: z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) + *'(0, z' - 1) :|: z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) + *'(z - 1, 0) :|: z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 0) + *'(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, z - 1) + *'(z - 1, 0) :|: z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, z' - 1) + *'(0, z' - 1) :|: z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 1 + (1 + plus(z - 2, z' - 2))) + *'(1 + (z - 2), 1 + (z' - 2)) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 0) + *'(1 + (z - 2), 1 + (z' - 2)) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 1 + (1 + plus(z - 2, z' - 2))) + *'(1 + (z - 2), 1 + (z' - 2)) :|: z - 2 >= 0, z' - 2 >= 0
   +'(z, z') -{ 1 }-> 1 + +'(z - 1, z' - 1) :|: z' - 1 >= 0, z - 1 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, times(z02, prod(z12))) + PROD(1 + z02 + z12) :|: z = 1 + z0 + (1 + z02 + z12), z02 >= 0, z0 >= 0, z12 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, 0) + PROD(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   PROD(z) -{ 1 }-> 1 + *'(z - 1, 1 + 0) + PROD(0) :|: z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + +'(z0, plus(z01, sum(z11))) + SUM(1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z0 >= 0, z = 1 + z0 + (1 + z01 + z11)
   SUM(z) -{ 1 }-> 1 + +'(z0, 0) + SUM(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 1 }-> 1 + +'(z - 1, 0) + SUM(0) :|: z - 1 >= 0
   plus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + (1 + plus(z - 1, z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   prod(z) -{ 0 }-> times(z0, times(z08, prod(z18))) :|: z08 >= 0, z18 >= 0, z0 >= 0, z = 1 + z0 + (1 + z08 + z18)
   prod(z) -{ 0 }-> times(z0, 0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   prod(z) -{ 0 }-> times(z - 1, 1 + 0) :|: z - 1 >= 0
   prod(z) -{ 0 }-> 0 :|: z >= 0
   prod(z) -{ 0 }-> 1 + 0 :|: z = 0
   sum(z) -{ 0 }-> plus(z0, plus(z07, sum(z17))) :|: z = 1 + z0 + (1 + z07 + z17), z07 >= 0, z17 >= 0, z0 >= 0
   sum(z) -{ 0 }-> plus(z0, 0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   sum(z) -{ 0 }-> plus(z - 1, 0) :|: z - 1 >= 0
   sum(z) -{ 0 }-> 0 :|: z = 0
   sum(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 0 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z' - 1 >= 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, z - 1) :|: z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, z' - 1) :|: z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + plus(0, 1 + (1 + plus(z - 2, z' - 2))) :|: z - 2 >= 0, z' - 2 >= 0
   times(z, z') -{ 0 }-> 1 + plus(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 0) :|: z' - 2 >= 0, z - 2 >= 0
   times(z, z') -{ 0 }-> 1 + plus(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 1 + (1 + plus(z - 2, z' - 2))) :|: z' - 2 >= 0, z - 2 >= 0

Function symbols to be analyzed: {plus}, {times}, {sum}, {prod}, {*'}, {SUM}, {PROD}
Previous analysis results are:
  +': runtime: O(n^1) [z'], size: O(1) [0]

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

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

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

   *'(z, z') -{ z' }-> 1 + s10 :|: s10 >= 0, s10 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s11 :|: s11 >= 0, s11 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s12 :|: s12 >= 0, s12 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ z' }-> 1 + s13 :|: s13 >= 0, s13 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ z }-> 1 + s7 :|: s7 >= 0, s7 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s9 :|: s9 >= 0, s9 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 1 + (1 + plus(z - 2, z' - 2))) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 0) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 1 + (1 + plus(z - 2, z' - 2))) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z }-> 1 + s' + *'(z - 1, 0) :|: s' >= 0, s' <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s'' + *'(0, 0) :|: s'' >= 0, s'' <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s1 + *'(z - 1, 0) :|: s1 >= 0, s1 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ z' }-> 1 + s2 + *'(0, z' - 1) :|: s2 >= 0, s2 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s3 + *'(0, z' - 1) :|: s3 >= 0, s3 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s4 + *'(z - 1, z' - 1) :|: s4 >= 0, s4 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 1 + (1 + plus(z - 2, z' - 2))) + *'(1 + (z - 2), 1 + (z' - 2)) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 0) + *'(1 + (z - 2), 1 + (z' - 2)) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 1 + (1 + plus(z - 2, z' - 2))) + *'(1 + (z - 2), 1 + (z' - 2)) :|: z - 2 >= 0, z' - 2 >= 0
   +'(z, z') -{ z' }-> 1 + s :|: s >= 0, s <= 0, z' - 1 >= 0, z - 1 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, times(z02, prod(z12))) + PROD(1 + z02 + z12) :|: z = 1 + z0 + (1 + z02 + z12), z02 >= 0, z0 >= 0, z12 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, 0) + PROD(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   PROD(z) -{ 1 }-> 1 + *'(z - 1, 1 + 0) + PROD(0) :|: z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + s5 + SUM(0) :|: s5 >= 0, s5 <= 0, z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + s6 + SUM(z1) :|: s6 >= 0, s6 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 1 }-> 1 + +'(z0, plus(z01, sum(z11))) + SUM(1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z0 >= 0, z = 1 + z0 + (1 + z01 + z11)
   plus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + (1 + plus(z - 1, z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   prod(z) -{ 0 }-> times(z0, times(z08, prod(z18))) :|: z08 >= 0, z18 >= 0, z0 >= 0, z = 1 + z0 + (1 + z08 + z18)
   prod(z) -{ 0 }-> times(z0, 0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   prod(z) -{ 0 }-> times(z - 1, 1 + 0) :|: z - 1 >= 0
   prod(z) -{ 0 }-> 0 :|: z >= 0
   prod(z) -{ 0 }-> 1 + 0 :|: z = 0
   sum(z) -{ 0 }-> plus(z0, plus(z07, sum(z17))) :|: z = 1 + z0 + (1 + z07 + z17), z07 >= 0, z17 >= 0, z0 >= 0
   sum(z) -{ 0 }-> plus(z0, 0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   sum(z) -{ 0 }-> plus(z - 1, 0) :|: z - 1 >= 0
   sum(z) -{ 0 }-> 0 :|: z = 0
   sum(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 0 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z' - 1 >= 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, z - 1) :|: z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, z' - 1) :|: z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + plus(0, 1 + (1 + plus(z - 2, z' - 2))) :|: z - 2 >= 0, z' - 2 >= 0
   times(z, z') -{ 0 }-> 1 + plus(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 0) :|: z' - 2 >= 0, z - 2 >= 0
   times(z, z') -{ 0 }-> 1 + plus(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 1 + (1 + plus(z - 2, z' - 2))) :|: z' - 2 >= 0, z - 2 >= 0

Function symbols to be analyzed: {plus}, {times}, {sum}, {prod}, {*'}, {SUM}, {PROD}
Previous analysis results are:
  +': runtime: O(n^1) [z'], size: O(1) [0]

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

(57) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   *'(z, z') -{ z' }-> 1 + s10 :|: s10 >= 0, s10 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s11 :|: s11 >= 0, s11 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s12 :|: s12 >= 0, s12 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ z' }-> 1 + s13 :|: s13 >= 0, s13 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ z }-> 1 + s7 :|: s7 >= 0, s7 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s9 :|: s9 >= 0, s9 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 1 + (1 + plus(z - 2, z' - 2))) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 0) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 1 + (1 + plus(z - 2, z' - 2))) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z }-> 1 + s' + *'(z - 1, 0) :|: s' >= 0, s' <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s'' + *'(0, 0) :|: s'' >= 0, s'' <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s1 + *'(z - 1, 0) :|: s1 >= 0, s1 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ z' }-> 1 + s2 + *'(0, z' - 1) :|: s2 >= 0, s2 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s3 + *'(0, z' - 1) :|: s3 >= 0, s3 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s4 + *'(z - 1, z' - 1) :|: s4 >= 0, s4 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 1 + (1 + plus(z - 2, z' - 2))) + *'(1 + (z - 2), 1 + (z' - 2)) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 0) + *'(1 + (z - 2), 1 + (z' - 2)) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 1 + (1 + plus(z - 2, z' - 2))) + *'(1 + (z - 2), 1 + (z' - 2)) :|: z - 2 >= 0, z' - 2 >= 0
   +'(z, z') -{ z' }-> 1 + s :|: s >= 0, s <= 0, z' - 1 >= 0, z - 1 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, times(z02, prod(z12))) + PROD(1 + z02 + z12) :|: z = 1 + z0 + (1 + z02 + z12), z02 >= 0, z0 >= 0, z12 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, 0) + PROD(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   PROD(z) -{ 1 }-> 1 + *'(z - 1, 1 + 0) + PROD(0) :|: z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + s5 + SUM(0) :|: s5 >= 0, s5 <= 0, z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + s6 + SUM(z1) :|: s6 >= 0, s6 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 1 }-> 1 + +'(z0, plus(z01, sum(z11))) + SUM(1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z0 >= 0, z = 1 + z0 + (1 + z01 + z11)
   plus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + (1 + plus(z - 1, z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   prod(z) -{ 0 }-> times(z0, times(z08, prod(z18))) :|: z08 >= 0, z18 >= 0, z0 >= 0, z = 1 + z0 + (1 + z08 + z18)
   prod(z) -{ 0 }-> times(z0, 0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   prod(z) -{ 0 }-> times(z - 1, 1 + 0) :|: z - 1 >= 0
   prod(z) -{ 0 }-> 0 :|: z >= 0
   prod(z) -{ 0 }-> 1 + 0 :|: z = 0
   sum(z) -{ 0 }-> plus(z0, plus(z07, sum(z17))) :|: z = 1 + z0 + (1 + z07 + z17), z07 >= 0, z17 >= 0, z0 >= 0
   sum(z) -{ 0 }-> plus(z0, 0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   sum(z) -{ 0 }-> plus(z - 1, 0) :|: z - 1 >= 0
   sum(z) -{ 0 }-> 0 :|: z = 0
   sum(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 0 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z' - 1 >= 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, z - 1) :|: z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, z' - 1) :|: z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + plus(0, 1 + (1 + plus(z - 2, z' - 2))) :|: z - 2 >= 0, z' - 2 >= 0
   times(z, z') -{ 0 }-> 1 + plus(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 0) :|: z' - 2 >= 0, z - 2 >= 0
   times(z, z') -{ 0 }-> 1 + plus(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 1 + (1 + plus(z - 2, z' - 2))) :|: z' - 2 >= 0, z - 2 >= 0

Function symbols to be analyzed: {plus}, {times}, {sum}, {prod}, {*'}, {SUM}, {PROD}
Previous analysis results are:
  +': runtime: O(n^1) [z'], size: O(1) [0]
  plus: runtime: ?, size: O(n^1) [z + z']

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

(59) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   *'(z, z') -{ z' }-> 1 + s10 :|: s10 >= 0, s10 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s11 :|: s11 >= 0, s11 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s12 :|: s12 >= 0, s12 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ z' }-> 1 + s13 :|: s13 >= 0, s13 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ z }-> 1 + s7 :|: s7 >= 0, s7 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s9 :|: s9 >= 0, s9 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 1 + (1 + plus(z - 2, z' - 2))) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 0) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 1 + (1 + plus(z - 2, z' - 2))) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z }-> 1 + s' + *'(z - 1, 0) :|: s' >= 0, s' <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s'' + *'(0, 0) :|: s'' >= 0, s'' <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s1 + *'(z - 1, 0) :|: s1 >= 0, s1 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ z' }-> 1 + s2 + *'(0, z' - 1) :|: s2 >= 0, s2 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s3 + *'(0, z' - 1) :|: s3 >= 0, s3 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s4 + *'(z - 1, z' - 1) :|: s4 >= 0, s4 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(0, 1 + (1 + plus(z - 2, z' - 2))) + *'(1 + (z - 2), 1 + (z' - 2)) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 0) + *'(1 + (z - 2), 1 + (z' - 2)) :|: z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 1 + (1 + plus(z - 2, z' - 2))) + *'(1 + (z - 2), 1 + (z' - 2)) :|: z - 2 >= 0, z' - 2 >= 0
   +'(z, z') -{ z' }-> 1 + s :|: s >= 0, s <= 0, z' - 1 >= 0, z - 1 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, times(z02, prod(z12))) + PROD(1 + z02 + z12) :|: z = 1 + z0 + (1 + z02 + z12), z02 >= 0, z0 >= 0, z12 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, 0) + PROD(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   PROD(z) -{ 1 }-> 1 + *'(z - 1, 1 + 0) + PROD(0) :|: z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + s5 + SUM(0) :|: s5 >= 0, s5 <= 0, z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + s6 + SUM(z1) :|: s6 >= 0, s6 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 1 }-> 1 + +'(z0, plus(z01, sum(z11))) + SUM(1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z0 >= 0, z = 1 + z0 + (1 + z01 + z11)
   plus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + (1 + plus(z - 1, z' - 1)) :|: z' - 1 >= 0, z - 1 >= 0
   prod(z) -{ 0 }-> times(z0, times(z08, prod(z18))) :|: z08 >= 0, z18 >= 0, z0 >= 0, z = 1 + z0 + (1 + z08 + z18)
   prod(z) -{ 0 }-> times(z0, 0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   prod(z) -{ 0 }-> times(z - 1, 1 + 0) :|: z - 1 >= 0
   prod(z) -{ 0 }-> 0 :|: z >= 0
   prod(z) -{ 0 }-> 1 + 0 :|: z = 0
   sum(z) -{ 0 }-> plus(z0, plus(z07, sum(z17))) :|: z = 1 + z0 + (1 + z07 + z17), z07 >= 0, z17 >= 0, z0 >= 0
   sum(z) -{ 0 }-> plus(z0, 0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   sum(z) -{ 0 }-> plus(z - 1, 0) :|: z - 1 >= 0
   sum(z) -{ 0 }-> 0 :|: z = 0
   sum(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 0 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + plus(0, 0) :|: z' - 1 >= 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, z - 1) :|: z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + plus(0, z' - 1) :|: z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + plus(0, 1 + (1 + plus(z - 2, z' - 2))) :|: z - 2 >= 0, z' - 2 >= 0
   times(z, z') -{ 0 }-> 1 + plus(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 0) :|: z' - 2 >= 0, z - 2 >= 0
   times(z, z') -{ 0 }-> 1 + plus(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 1 + (1 + plus(z - 2, z' - 2))) :|: z' - 2 >= 0, z - 2 >= 0

Function symbols to be analyzed: {times}, {sum}, {prod}, {*'}, {SUM}, {PROD}
Previous analysis results are:
  +': runtime: O(n^1) [z'], size: O(1) [0]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']

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

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

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

   *'(z, z') -{ z' }-> 1 + s10 :|: s10 >= 0, s10 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s11 :|: s11 >= 0, s11 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s12 :|: s12 >= 0, s12 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ z' }-> 1 + s13 :|: s13 >= 0, s13 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 3 + s22 }-> 1 + s23 :|: s22 >= 0, s22 <= z - 2 + (z' - 2), s23 >= 0, s23 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z }-> 1 + s7 :|: s7 >= 0, s7 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s9 :|: s9 >= 0, s9 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), s19), 1 + (1 + s20)) :|: s19 >= 0, s19 <= z - 2 + (z' - 2), s20 >= 0, s20 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), s21), 0) :|: s21 >= 0, s21 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z }-> 1 + s' + *'(z - 1, 0) :|: s' >= 0, s' <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s'' + *'(0, 0) :|: s'' >= 0, s'' <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s1 + *'(z - 1, 0) :|: s1 >= 0, s1 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 3 + s17 }-> 1 + s18 + *'(1 + (z - 2), 1 + (z' - 2)) :|: s17 >= 0, s17 <= z - 2 + (z' - 2), s18 >= 0, s18 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z' }-> 1 + s2 + *'(0, z' - 1) :|: s2 >= 0, s2 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s3 + *'(0, z' - 1) :|: s3 >= 0, s3 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s4 + *'(z - 1, z' - 1) :|: s4 >= 0, s4 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), s14), 1 + (1 + s15)) + *'(1 + (z - 2), 1 + (z' - 2)) :|: s14 >= 0, s14 <= z - 2 + (z' - 2), s15 >= 0, s15 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), s16), 0) + *'(1 + (z - 2), 1 + (z' - 2)) :|: s16 >= 0, s16 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   +'(z, z') -{ z' }-> 1 + s :|: s >= 0, s <= 0, z' - 1 >= 0, z - 1 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, times(z02, prod(z12))) + PROD(1 + z02 + z12) :|: z = 1 + z0 + (1 + z02 + z12), z02 >= 0, z0 >= 0, z12 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, 0) + PROD(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   PROD(z) -{ 1 }-> 1 + *'(z - 1, 1 + 0) + PROD(0) :|: z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + s5 + SUM(0) :|: s5 >= 0, s5 <= 0, z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + s6 + SUM(z1) :|: s6 >= 0, s6 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 1 }-> 1 + +'(z0, plus(z01, sum(z11))) + SUM(1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z0 >= 0, z = 1 + z0 + (1 + z01 + z11)
   plus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + (1 + s24) :|: s24 >= 0, s24 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   prod(z) -{ 0 }-> times(z0, times(z08, prod(z18))) :|: z08 >= 0, z18 >= 0, z0 >= 0, z = 1 + z0 + (1 + z08 + z18)
   prod(z) -{ 0 }-> times(z0, 0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   prod(z) -{ 0 }-> times(z - 1, 1 + 0) :|: z - 1 >= 0
   prod(z) -{ 0 }-> 0 :|: z >= 0
   prod(z) -{ 0 }-> 1 + 0 :|: z = 0
   sum(z) -{ 0 }-> s36 :|: s36 >= 0, s36 <= z - 1 + 0, z - 1 >= 0
   sum(z) -{ 0 }-> s37 :|: s37 >= 0, s37 <= z0 + 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   sum(z) -{ 0 }-> plus(z0, plus(z07, sum(z17))) :|: z = 1 + z0 + (1 + z07 + z17), z07 >= 0, z17 >= 0, z0 >= 0
   sum(z) -{ 0 }-> 0 :|: z = 0
   sum(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 0 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   times(z, z') -{ 0 }-> 1 + s25 :|: s25 >= 0, s25 <= 0 + (z - 1), z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s26 :|: s26 >= 0, s26 <= 0 + 0, z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 0 }-> 1 + s27 :|: s27 >= 0, s27 <= 0 + 0, z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s28 :|: s28 >= 0, s28 <= 0 + (z' - 1), z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s29 :|: s29 >= 0, s29 <= 0 + 0, z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s34 :|: s33 >= 0, s33 <= z - 2 + (z' - 2), s34 >= 0, s34 <= 0 + (1 + (1 + s33)), z - 2 >= 0, z' - 2 >= 0
   times(z, z') -{ 0 }-> 1 + s35 :|: s35 >= 0, s35 <= 0 + 0, z' - 1 >= 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + plus(1 + plus(times(z - 2, z' - 2), s30), 1 + (1 + s31)) :|: s30 >= 0, s30 <= z - 2 + (z' - 2), s31 >= 0, s31 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0
   times(z, z') -{ 0 }-> 1 + plus(1 + plus(times(z - 2, z' - 2), s32), 0) :|: s32 >= 0, s32 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0

Function symbols to be analyzed: {times}, {sum}, {prod}, {*'}, {SUM}, {PROD}
Previous analysis results are:
  +': runtime: O(n^1) [z'], size: O(1) [0]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']

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

(63) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   *'(z, z') -{ z' }-> 1 + s10 :|: s10 >= 0, s10 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s11 :|: s11 >= 0, s11 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s12 :|: s12 >= 0, s12 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ z' }-> 1 + s13 :|: s13 >= 0, s13 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 3 + s22 }-> 1 + s23 :|: s22 >= 0, s22 <= z - 2 + (z' - 2), s23 >= 0, s23 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z }-> 1 + s7 :|: s7 >= 0, s7 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s9 :|: s9 >= 0, s9 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), s19), 1 + (1 + s20)) :|: s19 >= 0, s19 <= z - 2 + (z' - 2), s20 >= 0, s20 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), s21), 0) :|: s21 >= 0, s21 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z }-> 1 + s' + *'(z - 1, 0) :|: s' >= 0, s' <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s'' + *'(0, 0) :|: s'' >= 0, s'' <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s1 + *'(z - 1, 0) :|: s1 >= 0, s1 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 3 + s17 }-> 1 + s18 + *'(1 + (z - 2), 1 + (z' - 2)) :|: s17 >= 0, s17 <= z - 2 + (z' - 2), s18 >= 0, s18 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z' }-> 1 + s2 + *'(0, z' - 1) :|: s2 >= 0, s2 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s3 + *'(0, z' - 1) :|: s3 >= 0, s3 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s4 + *'(z - 1, z' - 1) :|: s4 >= 0, s4 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), s14), 1 + (1 + s15)) + *'(1 + (z - 2), 1 + (z' - 2)) :|: s14 >= 0, s14 <= z - 2 + (z' - 2), s15 >= 0, s15 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), s16), 0) + *'(1 + (z - 2), 1 + (z' - 2)) :|: s16 >= 0, s16 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   +'(z, z') -{ z' }-> 1 + s :|: s >= 0, s <= 0, z' - 1 >= 0, z - 1 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, times(z02, prod(z12))) + PROD(1 + z02 + z12) :|: z = 1 + z0 + (1 + z02 + z12), z02 >= 0, z0 >= 0, z12 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, 0) + PROD(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   PROD(z) -{ 1 }-> 1 + *'(z - 1, 1 + 0) + PROD(0) :|: z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + s5 + SUM(0) :|: s5 >= 0, s5 <= 0, z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + s6 + SUM(z1) :|: s6 >= 0, s6 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 1 }-> 1 + +'(z0, plus(z01, sum(z11))) + SUM(1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z0 >= 0, z = 1 + z0 + (1 + z01 + z11)
   plus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + (1 + s24) :|: s24 >= 0, s24 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   prod(z) -{ 0 }-> times(z0, times(z08, prod(z18))) :|: z08 >= 0, z18 >= 0, z0 >= 0, z = 1 + z0 + (1 + z08 + z18)
   prod(z) -{ 0 }-> times(z0, 0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   prod(z) -{ 0 }-> times(z - 1, 1 + 0) :|: z - 1 >= 0
   prod(z) -{ 0 }-> 0 :|: z >= 0
   prod(z) -{ 0 }-> 1 + 0 :|: z = 0
   sum(z) -{ 0 }-> s36 :|: s36 >= 0, s36 <= z - 1 + 0, z - 1 >= 0
   sum(z) -{ 0 }-> s37 :|: s37 >= 0, s37 <= z0 + 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   sum(z) -{ 0 }-> plus(z0, plus(z07, sum(z17))) :|: z = 1 + z0 + (1 + z07 + z17), z07 >= 0, z17 >= 0, z0 >= 0
   sum(z) -{ 0 }-> 0 :|: z = 0
   sum(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 0 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   times(z, z') -{ 0 }-> 1 + s25 :|: s25 >= 0, s25 <= 0 + (z - 1), z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s26 :|: s26 >= 0, s26 <= 0 + 0, z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 0 }-> 1 + s27 :|: s27 >= 0, s27 <= 0 + 0, z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s28 :|: s28 >= 0, s28 <= 0 + (z' - 1), z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s29 :|: s29 >= 0, s29 <= 0 + 0, z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s34 :|: s33 >= 0, s33 <= z - 2 + (z' - 2), s34 >= 0, s34 <= 0 + (1 + (1 + s33)), z - 2 >= 0, z' - 2 >= 0
   times(z, z') -{ 0 }-> 1 + s35 :|: s35 >= 0, s35 <= 0 + 0, z' - 1 >= 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + plus(1 + plus(times(z - 2, z' - 2), s30), 1 + (1 + s31)) :|: s30 >= 0, s30 <= z - 2 + (z' - 2), s31 >= 0, s31 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0
   times(z, z') -{ 0 }-> 1 + plus(1 + plus(times(z - 2, z' - 2), s32), 0) :|: s32 >= 0, s32 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0

Function symbols to be analyzed: {times}, {sum}, {prod}, {*'}, {SUM}, {PROD}
Previous analysis results are:
  +': runtime: O(n^1) [z'], size: O(1) [0]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  times: runtime: ?, size: O(n^2) [7 + 8*z + 3*z*z' + 3*z^2 + 2*z']

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

(65) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   *'(z, z') -{ z' }-> 1 + s10 :|: s10 >= 0, s10 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s11 :|: s11 >= 0, s11 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s12 :|: s12 >= 0, s12 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ z' }-> 1 + s13 :|: s13 >= 0, s13 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 3 + s22 }-> 1 + s23 :|: s22 >= 0, s22 <= z - 2 + (z' - 2), s23 >= 0, s23 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z }-> 1 + s7 :|: s7 >= 0, s7 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s9 :|: s9 >= 0, s9 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), s19), 1 + (1 + s20)) :|: s19 >= 0, s19 <= z - 2 + (z' - 2), s20 >= 0, s20 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), s21), 0) :|: s21 >= 0, s21 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z }-> 1 + s' + *'(z - 1, 0) :|: s' >= 0, s' <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s'' + *'(0, 0) :|: s'' >= 0, s'' <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s1 + *'(z - 1, 0) :|: s1 >= 0, s1 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 3 + s17 }-> 1 + s18 + *'(1 + (z - 2), 1 + (z' - 2)) :|: s17 >= 0, s17 <= z - 2 + (z' - 2), s18 >= 0, s18 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z' }-> 1 + s2 + *'(0, z' - 1) :|: s2 >= 0, s2 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s3 + *'(0, z' - 1) :|: s3 >= 0, s3 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s4 + *'(z - 1, z' - 1) :|: s4 >= 0, s4 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), s14), 1 + (1 + s15)) + *'(1 + (z - 2), 1 + (z' - 2)) :|: s14 >= 0, s14 <= z - 2 + (z' - 2), s15 >= 0, s15 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + +'(1 + plus(times(z - 2, z' - 2), s16), 0) + *'(1 + (z - 2), 1 + (z' - 2)) :|: s16 >= 0, s16 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   +'(z, z') -{ z' }-> 1 + s :|: s >= 0, s <= 0, z' - 1 >= 0, z - 1 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, times(z02, prod(z12))) + PROD(1 + z02 + z12) :|: z = 1 + z0 + (1 + z02 + z12), z02 >= 0, z0 >= 0, z12 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, 0) + PROD(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   PROD(z) -{ 1 }-> 1 + *'(z - 1, 1 + 0) + PROD(0) :|: z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + s5 + SUM(0) :|: s5 >= 0, s5 <= 0, z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + s6 + SUM(z1) :|: s6 >= 0, s6 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 1 }-> 1 + +'(z0, plus(z01, sum(z11))) + SUM(1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z0 >= 0, z = 1 + z0 + (1 + z01 + z11)
   plus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + (1 + s24) :|: s24 >= 0, s24 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   prod(z) -{ 0 }-> times(z0, times(z08, prod(z18))) :|: z08 >= 0, z18 >= 0, z0 >= 0, z = 1 + z0 + (1 + z08 + z18)
   prod(z) -{ 0 }-> times(z0, 0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   prod(z) -{ 0 }-> times(z - 1, 1 + 0) :|: z - 1 >= 0
   prod(z) -{ 0 }-> 0 :|: z >= 0
   prod(z) -{ 0 }-> 1 + 0 :|: z = 0
   sum(z) -{ 0 }-> s36 :|: s36 >= 0, s36 <= z - 1 + 0, z - 1 >= 0
   sum(z) -{ 0 }-> s37 :|: s37 >= 0, s37 <= z0 + 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   sum(z) -{ 0 }-> plus(z0, plus(z07, sum(z17))) :|: z = 1 + z0 + (1 + z07 + z17), z07 >= 0, z17 >= 0, z0 >= 0
   sum(z) -{ 0 }-> 0 :|: z = 0
   sum(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 0 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   times(z, z') -{ 0 }-> 1 + s25 :|: s25 >= 0, s25 <= 0 + (z - 1), z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s26 :|: s26 >= 0, s26 <= 0 + 0, z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 0 }-> 1 + s27 :|: s27 >= 0, s27 <= 0 + 0, z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s28 :|: s28 >= 0, s28 <= 0 + (z' - 1), z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s29 :|: s29 >= 0, s29 <= 0 + 0, z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s34 :|: s33 >= 0, s33 <= z - 2 + (z' - 2), s34 >= 0, s34 <= 0 + (1 + (1 + s33)), z - 2 >= 0, z' - 2 >= 0
   times(z, z') -{ 0 }-> 1 + s35 :|: s35 >= 0, s35 <= 0 + 0, z' - 1 >= 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + plus(1 + plus(times(z - 2, z' - 2), s30), 1 + (1 + s31)) :|: s30 >= 0, s30 <= z - 2 + (z' - 2), s31 >= 0, s31 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0
   times(z, z') -{ 0 }-> 1 + plus(1 + plus(times(z - 2, z' - 2), s32), 0) :|: s32 >= 0, s32 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0

Function symbols to be analyzed: {sum}, {prod}, {*'}, {SUM}, {PROD}
Previous analysis results are:
  +': runtime: O(n^1) [z'], size: O(1) [0]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  times: runtime: O(1) [0], size: O(n^2) [7 + 8*z + 3*z*z' + 3*z^2 + 2*z']

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

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

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

   *'(z, z') -{ z' }-> 1 + s10 :|: s10 >= 0, s10 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s11 :|: s11 >= 0, s11 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s12 :|: s12 >= 0, s12 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ z' }-> 1 + s13 :|: s13 >= 0, s13 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 3 + s22 }-> 1 + s23 :|: s22 >= 0, s22 <= z - 2 + (z' - 2), s23 >= 0, s23 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 3 + s20 }-> 1 + s46 :|: s44 >= 0, s44 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s45 >= 0, s45 <= s44 + s19, s46 >= 0, s46 <= 0, s19 >= 0, s19 <= z - 2 + (z' - 2), s20 >= 0, s20 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + s49 :|: s47 >= 0, s47 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s48 >= 0, s48 <= s47 + s21, s49 >= 0, s49 <= 0, s21 >= 0, s21 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z }-> 1 + s7 :|: s7 >= 0, s7 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s9 :|: s9 >= 0, s9 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ z }-> 1 + s' + *'(z - 1, 0) :|: s' >= 0, s' <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s'' + *'(0, 0) :|: s'' >= 0, s'' <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s1 + *'(z - 1, 0) :|: s1 >= 0, s1 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 3 + s17 }-> 1 + s18 + *'(1 + (z - 2), 1 + (z' - 2)) :|: s17 >= 0, s17 <= z - 2 + (z' - 2), s18 >= 0, s18 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z' }-> 1 + s2 + *'(0, z' - 1) :|: s2 >= 0, s2 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s3 + *'(0, z' - 1) :|: s3 >= 0, s3 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s4 + *'(z - 1, z' - 1) :|: s4 >= 0, s4 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 3 + s15 }-> 1 + s40 + *'(1 + (z - 2), 1 + (z' - 2)) :|: s38 >= 0, s38 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s39 >= 0, s39 <= s38 + s14, s40 >= 0, s40 <= 0, s14 >= 0, s14 <= z - 2 + (z' - 2), s15 >= 0, s15 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + s43 + *'(1 + (z - 2), 1 + (z' - 2)) :|: s41 >= 0, s41 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s42 >= 0, s42 <= s41 + s16, s43 >= 0, s43 <= 0, s16 >= 0, s16 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   +'(z, z') -{ z' }-> 1 + s :|: s >= 0, s <= 0, z' - 1 >= 0, z - 1 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, times(z02, prod(z12))) + PROD(1 + z02 + z12) :|: z = 1 + z0 + (1 + z02 + z12), z02 >= 0, z0 >= 0, z12 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, 0) + PROD(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   PROD(z) -{ 1 }-> 1 + *'(z - 1, 1 + 0) + PROD(0) :|: z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + s5 + SUM(0) :|: s5 >= 0, s5 <= 0, z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + s6 + SUM(z1) :|: s6 >= 0, s6 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 1 }-> 1 + +'(z0, plus(z01, sum(z11))) + SUM(1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z0 >= 0, z = 1 + z0 + (1 + z01 + z11)
   plus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + (1 + s24) :|: s24 >= 0, s24 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   prod(z) -{ 0 }-> s56 :|: s56 >= 0, s56 <= 8 * (z - 1) + 2 * (1 + 0) + 3 * ((z - 1) * (z - 1)) + 3 * ((1 + 0) * (z - 1)) + 7, z - 1 >= 0
   prod(z) -{ 0 }-> s57 :|: s57 >= 0, s57 <= 8 * z0 + 2 * 0 + 3 * (z0 * z0) + 3 * (0 * z0) + 7, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   prod(z) -{ 0 }-> times(z0, times(z08, prod(z18))) :|: z08 >= 0, z18 >= 0, z0 >= 0, z = 1 + z0 + (1 + z08 + z18)
   prod(z) -{ 0 }-> 0 :|: z >= 0
   prod(z) -{ 0 }-> 1 + 0 :|: z = 0
   sum(z) -{ 0 }-> s36 :|: s36 >= 0, s36 <= z - 1 + 0, z - 1 >= 0
   sum(z) -{ 0 }-> s37 :|: s37 >= 0, s37 <= z0 + 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   sum(z) -{ 0 }-> plus(z0, plus(z07, sum(z17))) :|: z = 1 + z0 + (1 + z07 + z17), z07 >= 0, z17 >= 0, z0 >= 0
   sum(z) -{ 0 }-> 0 :|: z = 0
   sum(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 0 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   times(z, z') -{ 0 }-> 1 + s25 :|: s25 >= 0, s25 <= 0 + (z - 1), z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s26 :|: s26 >= 0, s26 <= 0 + 0, z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 0 }-> 1 + s27 :|: s27 >= 0, s27 <= 0 + 0, z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s28 :|: s28 >= 0, s28 <= 0 + (z' - 1), z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s29 :|: s29 >= 0, s29 <= 0 + 0, z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s34 :|: s33 >= 0, s33 <= z - 2 + (z' - 2), s34 >= 0, s34 <= 0 + (1 + (1 + s33)), z - 2 >= 0, z' - 2 >= 0
   times(z, z') -{ 0 }-> 1 + s35 :|: s35 >= 0, s35 <= 0 + 0, z' - 1 >= 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s52 :|: s50 >= 0, s50 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s51 >= 0, s51 <= s50 + s30, s52 >= 0, s52 <= 1 + s51 + (1 + (1 + s31)), s30 >= 0, s30 <= z - 2 + (z' - 2), s31 >= 0, s31 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0
   times(z, z') -{ 0 }-> 1 + s55 :|: s53 >= 0, s53 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s54 >= 0, s54 <= s53 + s32, s55 >= 0, s55 <= 1 + s54 + 0, s32 >= 0, s32 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0

Function symbols to be analyzed: {sum}, {prod}, {*'}, {SUM}, {PROD}
Previous analysis results are:
  +': runtime: O(n^1) [z'], size: O(1) [0]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  times: runtime: O(1) [0], size: O(n^2) [7 + 8*z + 3*z*z' + 3*z^2 + 2*z']

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

(69) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   *'(z, z') -{ z' }-> 1 + s10 :|: s10 >= 0, s10 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s11 :|: s11 >= 0, s11 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s12 :|: s12 >= 0, s12 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ z' }-> 1 + s13 :|: s13 >= 0, s13 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 3 + s22 }-> 1 + s23 :|: s22 >= 0, s22 <= z - 2 + (z' - 2), s23 >= 0, s23 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 3 + s20 }-> 1 + s46 :|: s44 >= 0, s44 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s45 >= 0, s45 <= s44 + s19, s46 >= 0, s46 <= 0, s19 >= 0, s19 <= z - 2 + (z' - 2), s20 >= 0, s20 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + s49 :|: s47 >= 0, s47 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s48 >= 0, s48 <= s47 + s21, s49 >= 0, s49 <= 0, s21 >= 0, s21 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z }-> 1 + s7 :|: s7 >= 0, s7 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s9 :|: s9 >= 0, s9 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ z }-> 1 + s' + *'(z - 1, 0) :|: s' >= 0, s' <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s'' + *'(0, 0) :|: s'' >= 0, s'' <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s1 + *'(z - 1, 0) :|: s1 >= 0, s1 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 3 + s17 }-> 1 + s18 + *'(1 + (z - 2), 1 + (z' - 2)) :|: s17 >= 0, s17 <= z - 2 + (z' - 2), s18 >= 0, s18 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z' }-> 1 + s2 + *'(0, z' - 1) :|: s2 >= 0, s2 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s3 + *'(0, z' - 1) :|: s3 >= 0, s3 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s4 + *'(z - 1, z' - 1) :|: s4 >= 0, s4 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 3 + s15 }-> 1 + s40 + *'(1 + (z - 2), 1 + (z' - 2)) :|: s38 >= 0, s38 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s39 >= 0, s39 <= s38 + s14, s40 >= 0, s40 <= 0, s14 >= 0, s14 <= z - 2 + (z' - 2), s15 >= 0, s15 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + s43 + *'(1 + (z - 2), 1 + (z' - 2)) :|: s41 >= 0, s41 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s42 >= 0, s42 <= s41 + s16, s43 >= 0, s43 <= 0, s16 >= 0, s16 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   +'(z, z') -{ z' }-> 1 + s :|: s >= 0, s <= 0, z' - 1 >= 0, z - 1 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, times(z02, prod(z12))) + PROD(1 + z02 + z12) :|: z = 1 + z0 + (1 + z02 + z12), z02 >= 0, z0 >= 0, z12 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, 0) + PROD(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   PROD(z) -{ 1 }-> 1 + *'(z - 1, 1 + 0) + PROD(0) :|: z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + s5 + SUM(0) :|: s5 >= 0, s5 <= 0, z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + s6 + SUM(z1) :|: s6 >= 0, s6 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 1 }-> 1 + +'(z0, plus(z01, sum(z11))) + SUM(1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z0 >= 0, z = 1 + z0 + (1 + z01 + z11)
   plus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + (1 + s24) :|: s24 >= 0, s24 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   prod(z) -{ 0 }-> s56 :|: s56 >= 0, s56 <= 8 * (z - 1) + 2 * (1 + 0) + 3 * ((z - 1) * (z - 1)) + 3 * ((1 + 0) * (z - 1)) + 7, z - 1 >= 0
   prod(z) -{ 0 }-> s57 :|: s57 >= 0, s57 <= 8 * z0 + 2 * 0 + 3 * (z0 * z0) + 3 * (0 * z0) + 7, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   prod(z) -{ 0 }-> times(z0, times(z08, prod(z18))) :|: z08 >= 0, z18 >= 0, z0 >= 0, z = 1 + z0 + (1 + z08 + z18)
   prod(z) -{ 0 }-> 0 :|: z >= 0
   prod(z) -{ 0 }-> 1 + 0 :|: z = 0
   sum(z) -{ 0 }-> s36 :|: s36 >= 0, s36 <= z - 1 + 0, z - 1 >= 0
   sum(z) -{ 0 }-> s37 :|: s37 >= 0, s37 <= z0 + 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   sum(z) -{ 0 }-> plus(z0, plus(z07, sum(z17))) :|: z = 1 + z0 + (1 + z07 + z17), z07 >= 0, z17 >= 0, z0 >= 0
   sum(z) -{ 0 }-> 0 :|: z = 0
   sum(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 0 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   times(z, z') -{ 0 }-> 1 + s25 :|: s25 >= 0, s25 <= 0 + (z - 1), z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s26 :|: s26 >= 0, s26 <= 0 + 0, z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 0 }-> 1 + s27 :|: s27 >= 0, s27 <= 0 + 0, z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s28 :|: s28 >= 0, s28 <= 0 + (z' - 1), z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s29 :|: s29 >= 0, s29 <= 0 + 0, z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s34 :|: s33 >= 0, s33 <= z - 2 + (z' - 2), s34 >= 0, s34 <= 0 + (1 + (1 + s33)), z - 2 >= 0, z' - 2 >= 0
   times(z, z') -{ 0 }-> 1 + s35 :|: s35 >= 0, s35 <= 0 + 0, z' - 1 >= 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s52 :|: s50 >= 0, s50 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s51 >= 0, s51 <= s50 + s30, s52 >= 0, s52 <= 1 + s51 + (1 + (1 + s31)), s30 >= 0, s30 <= z - 2 + (z' - 2), s31 >= 0, s31 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0
   times(z, z') -{ 0 }-> 1 + s55 :|: s53 >= 0, s53 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s54 >= 0, s54 <= s53 + s32, s55 >= 0, s55 <= 1 + s54 + 0, s32 >= 0, s32 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0

Function symbols to be analyzed: {sum}, {prod}, {*'}, {SUM}, {PROD}
Previous analysis results are:
  +': runtime: O(n^1) [z'], size: O(1) [0]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  times: runtime: O(1) [0], size: O(n^2) [7 + 8*z + 3*z*z' + 3*z^2 + 2*z']
  sum: runtime: ?, size: O(n^1) [z]

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

(71) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   *'(z, z') -{ z' }-> 1 + s10 :|: s10 >= 0, s10 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s11 :|: s11 >= 0, s11 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s12 :|: s12 >= 0, s12 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ z' }-> 1 + s13 :|: s13 >= 0, s13 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 3 + s22 }-> 1 + s23 :|: s22 >= 0, s22 <= z - 2 + (z' - 2), s23 >= 0, s23 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 3 + s20 }-> 1 + s46 :|: s44 >= 0, s44 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s45 >= 0, s45 <= s44 + s19, s46 >= 0, s46 <= 0, s19 >= 0, s19 <= z - 2 + (z' - 2), s20 >= 0, s20 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + s49 :|: s47 >= 0, s47 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s48 >= 0, s48 <= s47 + s21, s49 >= 0, s49 <= 0, s21 >= 0, s21 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z }-> 1 + s7 :|: s7 >= 0, s7 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s9 :|: s9 >= 0, s9 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ z }-> 1 + s' + *'(z - 1, 0) :|: s' >= 0, s' <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s'' + *'(0, 0) :|: s'' >= 0, s'' <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s1 + *'(z - 1, 0) :|: s1 >= 0, s1 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 3 + s17 }-> 1 + s18 + *'(1 + (z - 2), 1 + (z' - 2)) :|: s17 >= 0, s17 <= z - 2 + (z' - 2), s18 >= 0, s18 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z' }-> 1 + s2 + *'(0, z' - 1) :|: s2 >= 0, s2 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s3 + *'(0, z' - 1) :|: s3 >= 0, s3 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s4 + *'(z - 1, z' - 1) :|: s4 >= 0, s4 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 3 + s15 }-> 1 + s40 + *'(1 + (z - 2), 1 + (z' - 2)) :|: s38 >= 0, s38 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s39 >= 0, s39 <= s38 + s14, s40 >= 0, s40 <= 0, s14 >= 0, s14 <= z - 2 + (z' - 2), s15 >= 0, s15 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + s43 + *'(1 + (z - 2), 1 + (z' - 2)) :|: s41 >= 0, s41 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s42 >= 0, s42 <= s41 + s16, s43 >= 0, s43 <= 0, s16 >= 0, s16 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   +'(z, z') -{ z' }-> 1 + s :|: s >= 0, s <= 0, z' - 1 >= 0, z - 1 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, times(z02, prod(z12))) + PROD(1 + z02 + z12) :|: z = 1 + z0 + (1 + z02 + z12), z02 >= 0, z0 >= 0, z12 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, 0) + PROD(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   PROD(z) -{ 1 }-> 1 + *'(z - 1, 1 + 0) + PROD(0) :|: z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + s5 + SUM(0) :|: s5 >= 0, s5 <= 0, z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + s6 + SUM(z1) :|: s6 >= 0, s6 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 1 }-> 1 + +'(z0, plus(z01, sum(z11))) + SUM(1 + z01 + z11) :|: z11 >= 0, z01 >= 0, z0 >= 0, z = 1 + z0 + (1 + z01 + z11)
   plus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + (1 + s24) :|: s24 >= 0, s24 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   prod(z) -{ 0 }-> s56 :|: s56 >= 0, s56 <= 8 * (z - 1) + 2 * (1 + 0) + 3 * ((z - 1) * (z - 1)) + 3 * ((1 + 0) * (z - 1)) + 7, z - 1 >= 0
   prod(z) -{ 0 }-> s57 :|: s57 >= 0, s57 <= 8 * z0 + 2 * 0 + 3 * (z0 * z0) + 3 * (0 * z0) + 7, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   prod(z) -{ 0 }-> times(z0, times(z08, prod(z18))) :|: z08 >= 0, z18 >= 0, z0 >= 0, z = 1 + z0 + (1 + z08 + z18)
   prod(z) -{ 0 }-> 0 :|: z >= 0
   prod(z) -{ 0 }-> 1 + 0 :|: z = 0
   sum(z) -{ 0 }-> s36 :|: s36 >= 0, s36 <= z - 1 + 0, z - 1 >= 0
   sum(z) -{ 0 }-> s37 :|: s37 >= 0, s37 <= z0 + 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   sum(z) -{ 0 }-> plus(z0, plus(z07, sum(z17))) :|: z = 1 + z0 + (1 + z07 + z17), z07 >= 0, z17 >= 0, z0 >= 0
   sum(z) -{ 0 }-> 0 :|: z = 0
   sum(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 0 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   times(z, z') -{ 0 }-> 1 + s25 :|: s25 >= 0, s25 <= 0 + (z - 1), z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s26 :|: s26 >= 0, s26 <= 0 + 0, z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 0 }-> 1 + s27 :|: s27 >= 0, s27 <= 0 + 0, z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s28 :|: s28 >= 0, s28 <= 0 + (z' - 1), z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s29 :|: s29 >= 0, s29 <= 0 + 0, z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s34 :|: s33 >= 0, s33 <= z - 2 + (z' - 2), s34 >= 0, s34 <= 0 + (1 + (1 + s33)), z - 2 >= 0, z' - 2 >= 0
   times(z, z') -{ 0 }-> 1 + s35 :|: s35 >= 0, s35 <= 0 + 0, z' - 1 >= 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s52 :|: s50 >= 0, s50 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s51 >= 0, s51 <= s50 + s30, s52 >= 0, s52 <= 1 + s51 + (1 + (1 + s31)), s30 >= 0, s30 <= z - 2 + (z' - 2), s31 >= 0, s31 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0
   times(z, z') -{ 0 }-> 1 + s55 :|: s53 >= 0, s53 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s54 >= 0, s54 <= s53 + s32, s55 >= 0, s55 <= 1 + s54 + 0, s32 >= 0, s32 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0

Function symbols to be analyzed: {prod}, {*'}, {SUM}, {PROD}
Previous analysis results are:
  +': runtime: O(n^1) [z'], size: O(1) [0]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  times: runtime: O(1) [0], size: O(n^2) [7 + 8*z + 3*z*z' + 3*z^2 + 2*z']
  sum: runtime: O(1) [0], size: O(n^1) [z]

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

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

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

   *'(z, z') -{ z' }-> 1 + s10 :|: s10 >= 0, s10 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s11 :|: s11 >= 0, s11 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s12 :|: s12 >= 0, s12 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ z' }-> 1 + s13 :|: s13 >= 0, s13 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 3 + s22 }-> 1 + s23 :|: s22 >= 0, s22 <= z - 2 + (z' - 2), s23 >= 0, s23 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 3 + s20 }-> 1 + s46 :|: s44 >= 0, s44 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s45 >= 0, s45 <= s44 + s19, s46 >= 0, s46 <= 0, s19 >= 0, s19 <= z - 2 + (z' - 2), s20 >= 0, s20 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + s49 :|: s47 >= 0, s47 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s48 >= 0, s48 <= s47 + s21, s49 >= 0, s49 <= 0, s21 >= 0, s21 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z }-> 1 + s7 :|: s7 >= 0, s7 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s9 :|: s9 >= 0, s9 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ z }-> 1 + s' + *'(z - 1, 0) :|: s' >= 0, s' <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s'' + *'(0, 0) :|: s'' >= 0, s'' <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s1 + *'(z - 1, 0) :|: s1 >= 0, s1 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 3 + s17 }-> 1 + s18 + *'(1 + (z - 2), 1 + (z' - 2)) :|: s17 >= 0, s17 <= z - 2 + (z' - 2), s18 >= 0, s18 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z' }-> 1 + s2 + *'(0, z' - 1) :|: s2 >= 0, s2 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s3 + *'(0, z' - 1) :|: s3 >= 0, s3 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s4 + *'(z - 1, z' - 1) :|: s4 >= 0, s4 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 3 + s15 }-> 1 + s40 + *'(1 + (z - 2), 1 + (z' - 2)) :|: s38 >= 0, s38 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s39 >= 0, s39 <= s38 + s14, s40 >= 0, s40 <= 0, s14 >= 0, s14 <= z - 2 + (z' - 2), s15 >= 0, s15 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + s43 + *'(1 + (z - 2), 1 + (z' - 2)) :|: s41 >= 0, s41 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s42 >= 0, s42 <= s41 + s16, s43 >= 0, s43 <= 0, s16 >= 0, s16 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   +'(z, z') -{ z' }-> 1 + s :|: s >= 0, s <= 0, z' - 1 >= 0, z - 1 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, times(z02, prod(z12))) + PROD(1 + z02 + z12) :|: z = 1 + z0 + (1 + z02 + z12), z02 >= 0, z0 >= 0, z12 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, 0) + PROD(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   PROD(z) -{ 1 }-> 1 + *'(z - 1, 1 + 0) + PROD(0) :|: z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + s5 + SUM(0) :|: s5 >= 0, s5 <= 0, z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + s6 + SUM(z1) :|: s6 >= 0, s6 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 1 + s59 }-> 1 + s60 + SUM(1 + z01 + z11) :|: s58 >= 0, s58 <= z11, s59 >= 0, s59 <= z01 + s58, s60 >= 0, s60 <= 0, z11 >= 0, z01 >= 0, z0 >= 0, z = 1 + z0 + (1 + z01 + z11)
   plus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + (1 + s24) :|: s24 >= 0, s24 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   prod(z) -{ 0 }-> s56 :|: s56 >= 0, s56 <= 8 * (z - 1) + 2 * (1 + 0) + 3 * ((z - 1) * (z - 1)) + 3 * ((1 + 0) * (z - 1)) + 7, z - 1 >= 0
   prod(z) -{ 0 }-> s57 :|: s57 >= 0, s57 <= 8 * z0 + 2 * 0 + 3 * (z0 * z0) + 3 * (0 * z0) + 7, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   prod(z) -{ 0 }-> times(z0, times(z08, prod(z18))) :|: z08 >= 0, z18 >= 0, z0 >= 0, z = 1 + z0 + (1 + z08 + z18)
   prod(z) -{ 0 }-> 0 :|: z >= 0
   prod(z) -{ 0 }-> 1 + 0 :|: z = 0
   sum(z) -{ 0 }-> s36 :|: s36 >= 0, s36 <= z - 1 + 0, z - 1 >= 0
   sum(z) -{ 0 }-> s37 :|: s37 >= 0, s37 <= z0 + 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   sum(z) -{ 0 }-> s63 :|: s61 >= 0, s61 <= z17, s62 >= 0, s62 <= z07 + s61, s63 >= 0, s63 <= z0 + s62, z = 1 + z0 + (1 + z07 + z17), z07 >= 0, z17 >= 0, z0 >= 0
   sum(z) -{ 0 }-> 0 :|: z = 0
   sum(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 0 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   times(z, z') -{ 0 }-> 1 + s25 :|: s25 >= 0, s25 <= 0 + (z - 1), z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s26 :|: s26 >= 0, s26 <= 0 + 0, z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 0 }-> 1 + s27 :|: s27 >= 0, s27 <= 0 + 0, z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s28 :|: s28 >= 0, s28 <= 0 + (z' - 1), z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s29 :|: s29 >= 0, s29 <= 0 + 0, z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s34 :|: s33 >= 0, s33 <= z - 2 + (z' - 2), s34 >= 0, s34 <= 0 + (1 + (1 + s33)), z - 2 >= 0, z' - 2 >= 0
   times(z, z') -{ 0 }-> 1 + s35 :|: s35 >= 0, s35 <= 0 + 0, z' - 1 >= 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s52 :|: s50 >= 0, s50 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s51 >= 0, s51 <= s50 + s30, s52 >= 0, s52 <= 1 + s51 + (1 + (1 + s31)), s30 >= 0, s30 <= z - 2 + (z' - 2), s31 >= 0, s31 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0
   times(z, z') -{ 0 }-> 1 + s55 :|: s53 >= 0, s53 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s54 >= 0, s54 <= s53 + s32, s55 >= 0, s55 <= 1 + s54 + 0, s32 >= 0, s32 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0

Function symbols to be analyzed: {prod}, {*'}, {SUM}, {PROD}
Previous analysis results are:
  +': runtime: O(n^1) [z'], size: O(1) [0]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  times: runtime: O(1) [0], size: O(n^2) [7 + 8*z + 3*z*z' + 3*z^2 + 2*z']
  sum: runtime: O(1) [0], size: O(n^1) [z]

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

(75) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   *'(z, z') -{ z' }-> 1 + s10 :|: s10 >= 0, s10 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s11 :|: s11 >= 0, s11 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s12 :|: s12 >= 0, s12 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ z' }-> 1 + s13 :|: s13 >= 0, s13 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 3 + s22 }-> 1 + s23 :|: s22 >= 0, s22 <= z - 2 + (z' - 2), s23 >= 0, s23 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 3 + s20 }-> 1 + s46 :|: s44 >= 0, s44 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s45 >= 0, s45 <= s44 + s19, s46 >= 0, s46 <= 0, s19 >= 0, s19 <= z - 2 + (z' - 2), s20 >= 0, s20 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + s49 :|: s47 >= 0, s47 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s48 >= 0, s48 <= s47 + s21, s49 >= 0, s49 <= 0, s21 >= 0, s21 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z }-> 1 + s7 :|: s7 >= 0, s7 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s9 :|: s9 >= 0, s9 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ z }-> 1 + s' + *'(z - 1, 0) :|: s' >= 0, s' <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s'' + *'(0, 0) :|: s'' >= 0, s'' <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s1 + *'(z - 1, 0) :|: s1 >= 0, s1 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 3 + s17 }-> 1 + s18 + *'(1 + (z - 2), 1 + (z' - 2)) :|: s17 >= 0, s17 <= z - 2 + (z' - 2), s18 >= 0, s18 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z' }-> 1 + s2 + *'(0, z' - 1) :|: s2 >= 0, s2 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s3 + *'(0, z' - 1) :|: s3 >= 0, s3 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s4 + *'(z - 1, z' - 1) :|: s4 >= 0, s4 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 3 + s15 }-> 1 + s40 + *'(1 + (z - 2), 1 + (z' - 2)) :|: s38 >= 0, s38 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s39 >= 0, s39 <= s38 + s14, s40 >= 0, s40 <= 0, s14 >= 0, s14 <= z - 2 + (z' - 2), s15 >= 0, s15 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + s43 + *'(1 + (z - 2), 1 + (z' - 2)) :|: s41 >= 0, s41 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s42 >= 0, s42 <= s41 + s16, s43 >= 0, s43 <= 0, s16 >= 0, s16 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   +'(z, z') -{ z' }-> 1 + s :|: s >= 0, s <= 0, z' - 1 >= 0, z - 1 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, times(z02, prod(z12))) + PROD(1 + z02 + z12) :|: z = 1 + z0 + (1 + z02 + z12), z02 >= 0, z0 >= 0, z12 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, 0) + PROD(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   PROD(z) -{ 1 }-> 1 + *'(z - 1, 1 + 0) + PROD(0) :|: z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + s5 + SUM(0) :|: s5 >= 0, s5 <= 0, z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + s6 + SUM(z1) :|: s6 >= 0, s6 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 1 + s59 }-> 1 + s60 + SUM(1 + z01 + z11) :|: s58 >= 0, s58 <= z11, s59 >= 0, s59 <= z01 + s58, s60 >= 0, s60 <= 0, z11 >= 0, z01 >= 0, z0 >= 0, z = 1 + z0 + (1 + z01 + z11)
   plus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + (1 + s24) :|: s24 >= 0, s24 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   prod(z) -{ 0 }-> s56 :|: s56 >= 0, s56 <= 8 * (z - 1) + 2 * (1 + 0) + 3 * ((z - 1) * (z - 1)) + 3 * ((1 + 0) * (z - 1)) + 7, z - 1 >= 0
   prod(z) -{ 0 }-> s57 :|: s57 >= 0, s57 <= 8 * z0 + 2 * 0 + 3 * (z0 * z0) + 3 * (0 * z0) + 7, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   prod(z) -{ 0 }-> times(z0, times(z08, prod(z18))) :|: z08 >= 0, z18 >= 0, z0 >= 0, z = 1 + z0 + (1 + z08 + z18)
   prod(z) -{ 0 }-> 0 :|: z >= 0
   prod(z) -{ 0 }-> 1 + 0 :|: z = 0
   sum(z) -{ 0 }-> s36 :|: s36 >= 0, s36 <= z - 1 + 0, z - 1 >= 0
   sum(z) -{ 0 }-> s37 :|: s37 >= 0, s37 <= z0 + 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   sum(z) -{ 0 }-> s63 :|: s61 >= 0, s61 <= z17, s62 >= 0, s62 <= z07 + s61, s63 >= 0, s63 <= z0 + s62, z = 1 + z0 + (1 + z07 + z17), z07 >= 0, z17 >= 0, z0 >= 0
   sum(z) -{ 0 }-> 0 :|: z = 0
   sum(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 0 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   times(z, z') -{ 0 }-> 1 + s25 :|: s25 >= 0, s25 <= 0 + (z - 1), z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s26 :|: s26 >= 0, s26 <= 0 + 0, z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 0 }-> 1 + s27 :|: s27 >= 0, s27 <= 0 + 0, z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s28 :|: s28 >= 0, s28 <= 0 + (z' - 1), z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s29 :|: s29 >= 0, s29 <= 0 + 0, z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s34 :|: s33 >= 0, s33 <= z - 2 + (z' - 2), s34 >= 0, s34 <= 0 + (1 + (1 + s33)), z - 2 >= 0, z' - 2 >= 0
   times(z, z') -{ 0 }-> 1 + s35 :|: s35 >= 0, s35 <= 0 + 0, z' - 1 >= 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s52 :|: s50 >= 0, s50 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s51 >= 0, s51 <= s50 + s30, s52 >= 0, s52 <= 1 + s51 + (1 + (1 + s31)), s30 >= 0, s30 <= z - 2 + (z' - 2), s31 >= 0, s31 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0
   times(z, z') -{ 0 }-> 1 + s55 :|: s53 >= 0, s53 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s54 >= 0, s54 <= s53 + s32, s55 >= 0, s55 <= 1 + s54 + 0, s32 >= 0, s32 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0

Function symbols to be analyzed: {prod}, {*'}, {SUM}, {PROD}
Previous analysis results are:
  +': runtime: O(n^1) [z'], size: O(1) [0]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  times: runtime: O(1) [0], size: O(n^2) [7 + 8*z + 3*z*z' + 3*z^2 + 2*z']
  sum: runtime: O(1) [0], size: O(n^1) [z]
  prod: runtime: ?, size: INF

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

(77) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   *'(z, z') -{ z' }-> 1 + s10 :|: s10 >= 0, s10 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s11 :|: s11 >= 0, s11 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s12 :|: s12 >= 0, s12 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ z' }-> 1 + s13 :|: s13 >= 0, s13 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 3 + s22 }-> 1 + s23 :|: s22 >= 0, s22 <= z - 2 + (z' - 2), s23 >= 0, s23 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 3 + s20 }-> 1 + s46 :|: s44 >= 0, s44 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s45 >= 0, s45 <= s44 + s19, s46 >= 0, s46 <= 0, s19 >= 0, s19 <= z - 2 + (z' - 2), s20 >= 0, s20 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + s49 :|: s47 >= 0, s47 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s48 >= 0, s48 <= s47 + s21, s49 >= 0, s49 <= 0, s21 >= 0, s21 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z }-> 1 + s7 :|: s7 >= 0, s7 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s9 :|: s9 >= 0, s9 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ z }-> 1 + s' + *'(z - 1, 0) :|: s' >= 0, s' <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s'' + *'(0, 0) :|: s'' >= 0, s'' <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s1 + *'(z - 1, 0) :|: s1 >= 0, s1 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 3 + s17 }-> 1 + s18 + *'(1 + (z - 2), 1 + (z' - 2)) :|: s17 >= 0, s17 <= z - 2 + (z' - 2), s18 >= 0, s18 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z' }-> 1 + s2 + *'(0, z' - 1) :|: s2 >= 0, s2 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s3 + *'(0, z' - 1) :|: s3 >= 0, s3 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s4 + *'(z - 1, z' - 1) :|: s4 >= 0, s4 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 3 + s15 }-> 1 + s40 + *'(1 + (z - 2), 1 + (z' - 2)) :|: s38 >= 0, s38 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s39 >= 0, s39 <= s38 + s14, s40 >= 0, s40 <= 0, s14 >= 0, s14 <= z - 2 + (z' - 2), s15 >= 0, s15 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + s43 + *'(1 + (z - 2), 1 + (z' - 2)) :|: s41 >= 0, s41 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s42 >= 0, s42 <= s41 + s16, s43 >= 0, s43 <= 0, s16 >= 0, s16 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   +'(z, z') -{ z' }-> 1 + s :|: s >= 0, s <= 0, z' - 1 >= 0, z - 1 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, times(z02, prod(z12))) + PROD(1 + z02 + z12) :|: z = 1 + z0 + (1 + z02 + z12), z02 >= 0, z0 >= 0, z12 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, 0) + PROD(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   PROD(z) -{ 1 }-> 1 + *'(z - 1, 1 + 0) + PROD(0) :|: z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + s5 + SUM(0) :|: s5 >= 0, s5 <= 0, z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + s6 + SUM(z1) :|: s6 >= 0, s6 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 1 + s59 }-> 1 + s60 + SUM(1 + z01 + z11) :|: s58 >= 0, s58 <= z11, s59 >= 0, s59 <= z01 + s58, s60 >= 0, s60 <= 0, z11 >= 0, z01 >= 0, z0 >= 0, z = 1 + z0 + (1 + z01 + z11)
   plus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + (1 + s24) :|: s24 >= 0, s24 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   prod(z) -{ 0 }-> s56 :|: s56 >= 0, s56 <= 8 * (z - 1) + 2 * (1 + 0) + 3 * ((z - 1) * (z - 1)) + 3 * ((1 + 0) * (z - 1)) + 7, z - 1 >= 0
   prod(z) -{ 0 }-> s57 :|: s57 >= 0, s57 <= 8 * z0 + 2 * 0 + 3 * (z0 * z0) + 3 * (0 * z0) + 7, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   prod(z) -{ 0 }-> times(z0, times(z08, prod(z18))) :|: z08 >= 0, z18 >= 0, z0 >= 0, z = 1 + z0 + (1 + z08 + z18)
   prod(z) -{ 0 }-> 0 :|: z >= 0
   prod(z) -{ 0 }-> 1 + 0 :|: z = 0
   sum(z) -{ 0 }-> s36 :|: s36 >= 0, s36 <= z - 1 + 0, z - 1 >= 0
   sum(z) -{ 0 }-> s37 :|: s37 >= 0, s37 <= z0 + 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   sum(z) -{ 0 }-> s63 :|: s61 >= 0, s61 <= z17, s62 >= 0, s62 <= z07 + s61, s63 >= 0, s63 <= z0 + s62, z = 1 + z0 + (1 + z07 + z17), z07 >= 0, z17 >= 0, z0 >= 0
   sum(z) -{ 0 }-> 0 :|: z = 0
   sum(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 0 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   times(z, z') -{ 0 }-> 1 + s25 :|: s25 >= 0, s25 <= 0 + (z - 1), z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s26 :|: s26 >= 0, s26 <= 0 + 0, z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 0 }-> 1 + s27 :|: s27 >= 0, s27 <= 0 + 0, z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s28 :|: s28 >= 0, s28 <= 0 + (z' - 1), z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s29 :|: s29 >= 0, s29 <= 0 + 0, z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s34 :|: s33 >= 0, s33 <= z - 2 + (z' - 2), s34 >= 0, s34 <= 0 + (1 + (1 + s33)), z - 2 >= 0, z' - 2 >= 0
   times(z, z') -{ 0 }-> 1 + s35 :|: s35 >= 0, s35 <= 0 + 0, z' - 1 >= 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s52 :|: s50 >= 0, s50 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s51 >= 0, s51 <= s50 + s30, s52 >= 0, s52 <= 1 + s51 + (1 + (1 + s31)), s30 >= 0, s30 <= z - 2 + (z' - 2), s31 >= 0, s31 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0
   times(z, z') -{ 0 }-> 1 + s55 :|: s53 >= 0, s53 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s54 >= 0, s54 <= s53 + s32, s55 >= 0, s55 <= 1 + s54 + 0, s32 >= 0, s32 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0

Function symbols to be analyzed: {*'}, {SUM}, {PROD}
Previous analysis results are:
  +': runtime: O(n^1) [z'], size: O(1) [0]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  times: runtime: O(1) [0], size: O(n^2) [7 + 8*z + 3*z*z' + 3*z^2 + 2*z']
  sum: runtime: O(1) [0], size: O(n^1) [z]
  prod: runtime: O(1) [0], size: INF

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

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

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

   *'(z, z') -{ z' }-> 1 + s10 :|: s10 >= 0, s10 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s11 :|: s11 >= 0, s11 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s12 :|: s12 >= 0, s12 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ z' }-> 1 + s13 :|: s13 >= 0, s13 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 3 + s22 }-> 1 + s23 :|: s22 >= 0, s22 <= z - 2 + (z' - 2), s23 >= 0, s23 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 3 + s20 }-> 1 + s46 :|: s44 >= 0, s44 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s45 >= 0, s45 <= s44 + s19, s46 >= 0, s46 <= 0, s19 >= 0, s19 <= z - 2 + (z' - 2), s20 >= 0, s20 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + s49 :|: s47 >= 0, s47 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s48 >= 0, s48 <= s47 + s21, s49 >= 0, s49 <= 0, s21 >= 0, s21 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z }-> 1 + s7 :|: s7 >= 0, s7 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s9 :|: s9 >= 0, s9 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ z }-> 1 + s' + *'(z - 1, 0) :|: s' >= 0, s' <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s'' + *'(0, 0) :|: s'' >= 0, s'' <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s1 + *'(z - 1, 0) :|: s1 >= 0, s1 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 3 + s17 }-> 1 + s18 + *'(1 + (z - 2), 1 + (z' - 2)) :|: s17 >= 0, s17 <= z - 2 + (z' - 2), s18 >= 0, s18 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z' }-> 1 + s2 + *'(0, z' - 1) :|: s2 >= 0, s2 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s3 + *'(0, z' - 1) :|: s3 >= 0, s3 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s4 + *'(z - 1, z' - 1) :|: s4 >= 0, s4 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 3 + s15 }-> 1 + s40 + *'(1 + (z - 2), 1 + (z' - 2)) :|: s38 >= 0, s38 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s39 >= 0, s39 <= s38 + s14, s40 >= 0, s40 <= 0, s14 >= 0, s14 <= z - 2 + (z' - 2), s15 >= 0, s15 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + s43 + *'(1 + (z - 2), 1 + (z' - 2)) :|: s41 >= 0, s41 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s42 >= 0, s42 <= s41 + s16, s43 >= 0, s43 <= 0, s16 >= 0, s16 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   +'(z, z') -{ z' }-> 1 + s :|: s >= 0, s <= 0, z' - 1 >= 0, z - 1 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, s65) + PROD(1 + z02 + z12) :|: s64 >= 0, s64 <= inf, s65 >= 0, s65 <= 8 * z02 + 2 * s64 + 3 * (z02 * z02) + 3 * (s64 * z02) + 7, z = 1 + z0 + (1 + z02 + z12), z02 >= 0, z0 >= 0, z12 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, 0) + PROD(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   PROD(z) -{ 1 }-> 1 + *'(z - 1, 1 + 0) + PROD(0) :|: z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + s5 + SUM(0) :|: s5 >= 0, s5 <= 0, z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + s6 + SUM(z1) :|: s6 >= 0, s6 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 1 + s59 }-> 1 + s60 + SUM(1 + z01 + z11) :|: s58 >= 0, s58 <= z11, s59 >= 0, s59 <= z01 + s58, s60 >= 0, s60 <= 0, z11 >= 0, z01 >= 0, z0 >= 0, z = 1 + z0 + (1 + z01 + z11)
   plus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + (1 + s24) :|: s24 >= 0, s24 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   prod(z) -{ 0 }-> s56 :|: s56 >= 0, s56 <= 8 * (z - 1) + 2 * (1 + 0) + 3 * ((z - 1) * (z - 1)) + 3 * ((1 + 0) * (z - 1)) + 7, z - 1 >= 0
   prod(z) -{ 0 }-> s57 :|: s57 >= 0, s57 <= 8 * z0 + 2 * 0 + 3 * (z0 * z0) + 3 * (0 * z0) + 7, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   prod(z) -{ 0 }-> s68 :|: s66 >= 0, s66 <= inf', s67 >= 0, s67 <= 8 * z08 + 2 * s66 + 3 * (z08 * z08) + 3 * (s66 * z08) + 7, s68 >= 0, s68 <= 8 * z0 + 2 * s67 + 3 * (z0 * z0) + 3 * (s67 * z0) + 7, z08 >= 0, z18 >= 0, z0 >= 0, z = 1 + z0 + (1 + z08 + z18)
   prod(z) -{ 0 }-> 0 :|: z >= 0
   prod(z) -{ 0 }-> 1 + 0 :|: z = 0
   sum(z) -{ 0 }-> s36 :|: s36 >= 0, s36 <= z - 1 + 0, z - 1 >= 0
   sum(z) -{ 0 }-> s37 :|: s37 >= 0, s37 <= z0 + 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   sum(z) -{ 0 }-> s63 :|: s61 >= 0, s61 <= z17, s62 >= 0, s62 <= z07 + s61, s63 >= 0, s63 <= z0 + s62, z = 1 + z0 + (1 + z07 + z17), z07 >= 0, z17 >= 0, z0 >= 0
   sum(z) -{ 0 }-> 0 :|: z = 0
   sum(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 0 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   times(z, z') -{ 0 }-> 1 + s25 :|: s25 >= 0, s25 <= 0 + (z - 1), z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s26 :|: s26 >= 0, s26 <= 0 + 0, z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 0 }-> 1 + s27 :|: s27 >= 0, s27 <= 0 + 0, z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s28 :|: s28 >= 0, s28 <= 0 + (z' - 1), z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s29 :|: s29 >= 0, s29 <= 0 + 0, z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s34 :|: s33 >= 0, s33 <= z - 2 + (z' - 2), s34 >= 0, s34 <= 0 + (1 + (1 + s33)), z - 2 >= 0, z' - 2 >= 0
   times(z, z') -{ 0 }-> 1 + s35 :|: s35 >= 0, s35 <= 0 + 0, z' - 1 >= 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s52 :|: s50 >= 0, s50 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s51 >= 0, s51 <= s50 + s30, s52 >= 0, s52 <= 1 + s51 + (1 + (1 + s31)), s30 >= 0, s30 <= z - 2 + (z' - 2), s31 >= 0, s31 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0
   times(z, z') -{ 0 }-> 1 + s55 :|: s53 >= 0, s53 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s54 >= 0, s54 <= s53 + s32, s55 >= 0, s55 <= 1 + s54 + 0, s32 >= 0, s32 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0

Function symbols to be analyzed: {*'}, {SUM}, {PROD}
Previous analysis results are:
  +': runtime: O(n^1) [z'], size: O(1) [0]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  times: runtime: O(1) [0], size: O(n^2) [7 + 8*z + 3*z*z' + 3*z^2 + 2*z']
  sum: runtime: O(1) [0], size: O(n^1) [z]
  prod: runtime: O(1) [0], size: INF

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

(81) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   *'(z, z') -{ z' }-> 1 + s10 :|: s10 >= 0, s10 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s11 :|: s11 >= 0, s11 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s12 :|: s12 >= 0, s12 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ z' }-> 1 + s13 :|: s13 >= 0, s13 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 3 + s22 }-> 1 + s23 :|: s22 >= 0, s22 <= z - 2 + (z' - 2), s23 >= 0, s23 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 3 + s20 }-> 1 + s46 :|: s44 >= 0, s44 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s45 >= 0, s45 <= s44 + s19, s46 >= 0, s46 <= 0, s19 >= 0, s19 <= z - 2 + (z' - 2), s20 >= 0, s20 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + s49 :|: s47 >= 0, s47 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s48 >= 0, s48 <= s47 + s21, s49 >= 0, s49 <= 0, s21 >= 0, s21 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z }-> 1 + s7 :|: s7 >= 0, s7 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s9 :|: s9 >= 0, s9 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ z }-> 1 + s' + *'(z - 1, 0) :|: s' >= 0, s' <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s'' + *'(0, 0) :|: s'' >= 0, s'' <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s1 + *'(z - 1, 0) :|: s1 >= 0, s1 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 3 + s17 }-> 1 + s18 + *'(1 + (z - 2), 1 + (z' - 2)) :|: s17 >= 0, s17 <= z - 2 + (z' - 2), s18 >= 0, s18 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z' }-> 1 + s2 + *'(0, z' - 1) :|: s2 >= 0, s2 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s3 + *'(0, z' - 1) :|: s3 >= 0, s3 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s4 + *'(z - 1, z' - 1) :|: s4 >= 0, s4 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 3 + s15 }-> 1 + s40 + *'(1 + (z - 2), 1 + (z' - 2)) :|: s38 >= 0, s38 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s39 >= 0, s39 <= s38 + s14, s40 >= 0, s40 <= 0, s14 >= 0, s14 <= z - 2 + (z' - 2), s15 >= 0, s15 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + s43 + *'(1 + (z - 2), 1 + (z' - 2)) :|: s41 >= 0, s41 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s42 >= 0, s42 <= s41 + s16, s43 >= 0, s43 <= 0, s16 >= 0, s16 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   +'(z, z') -{ z' }-> 1 + s :|: s >= 0, s <= 0, z' - 1 >= 0, z - 1 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, s65) + PROD(1 + z02 + z12) :|: s64 >= 0, s64 <= inf, s65 >= 0, s65 <= 8 * z02 + 2 * s64 + 3 * (z02 * z02) + 3 * (s64 * z02) + 7, z = 1 + z0 + (1 + z02 + z12), z02 >= 0, z0 >= 0, z12 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, 0) + PROD(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   PROD(z) -{ 1 }-> 1 + *'(z - 1, 1 + 0) + PROD(0) :|: z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + s5 + SUM(0) :|: s5 >= 0, s5 <= 0, z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + s6 + SUM(z1) :|: s6 >= 0, s6 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 1 + s59 }-> 1 + s60 + SUM(1 + z01 + z11) :|: s58 >= 0, s58 <= z11, s59 >= 0, s59 <= z01 + s58, s60 >= 0, s60 <= 0, z11 >= 0, z01 >= 0, z0 >= 0, z = 1 + z0 + (1 + z01 + z11)
   plus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + (1 + s24) :|: s24 >= 0, s24 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   prod(z) -{ 0 }-> s56 :|: s56 >= 0, s56 <= 8 * (z - 1) + 2 * (1 + 0) + 3 * ((z - 1) * (z - 1)) + 3 * ((1 + 0) * (z - 1)) + 7, z - 1 >= 0
   prod(z) -{ 0 }-> s57 :|: s57 >= 0, s57 <= 8 * z0 + 2 * 0 + 3 * (z0 * z0) + 3 * (0 * z0) + 7, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   prod(z) -{ 0 }-> s68 :|: s66 >= 0, s66 <= inf', s67 >= 0, s67 <= 8 * z08 + 2 * s66 + 3 * (z08 * z08) + 3 * (s66 * z08) + 7, s68 >= 0, s68 <= 8 * z0 + 2 * s67 + 3 * (z0 * z0) + 3 * (s67 * z0) + 7, z08 >= 0, z18 >= 0, z0 >= 0, z = 1 + z0 + (1 + z08 + z18)
   prod(z) -{ 0 }-> 0 :|: z >= 0
   prod(z) -{ 0 }-> 1 + 0 :|: z = 0
   sum(z) -{ 0 }-> s36 :|: s36 >= 0, s36 <= z - 1 + 0, z - 1 >= 0
   sum(z) -{ 0 }-> s37 :|: s37 >= 0, s37 <= z0 + 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   sum(z) -{ 0 }-> s63 :|: s61 >= 0, s61 <= z17, s62 >= 0, s62 <= z07 + s61, s63 >= 0, s63 <= z0 + s62, z = 1 + z0 + (1 + z07 + z17), z07 >= 0, z17 >= 0, z0 >= 0
   sum(z) -{ 0 }-> 0 :|: z = 0
   sum(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 0 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   times(z, z') -{ 0 }-> 1 + s25 :|: s25 >= 0, s25 <= 0 + (z - 1), z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s26 :|: s26 >= 0, s26 <= 0 + 0, z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 0 }-> 1 + s27 :|: s27 >= 0, s27 <= 0 + 0, z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s28 :|: s28 >= 0, s28 <= 0 + (z' - 1), z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s29 :|: s29 >= 0, s29 <= 0 + 0, z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s34 :|: s33 >= 0, s33 <= z - 2 + (z' - 2), s34 >= 0, s34 <= 0 + (1 + (1 + s33)), z - 2 >= 0, z' - 2 >= 0
   times(z, z') -{ 0 }-> 1 + s35 :|: s35 >= 0, s35 <= 0 + 0, z' - 1 >= 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s52 :|: s50 >= 0, s50 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s51 >= 0, s51 <= s50 + s30, s52 >= 0, s52 <= 1 + s51 + (1 + (1 + s31)), s30 >= 0, s30 <= z - 2 + (z' - 2), s31 >= 0, s31 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0
   times(z, z') -{ 0 }-> 1 + s55 :|: s53 >= 0, s53 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s54 >= 0, s54 <= s53 + s32, s55 >= 0, s55 <= 1 + s54 + 0, s32 >= 0, s32 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0

Function symbols to be analyzed: {*'}, {SUM}, {PROD}
Previous analysis results are:
  +': runtime: O(n^1) [z'], size: O(1) [0]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  times: runtime: O(1) [0], size: O(n^2) [7 + 8*z + 3*z*z' + 3*z^2 + 2*z']
  sum: runtime: O(1) [0], size: O(n^1) [z]
  prod: runtime: O(1) [0], size: INF
  *': runtime: ?, size: O(n^1) [z']

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

(83) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   *'(z, z') -{ z' }-> 1 + s10 :|: s10 >= 0, s10 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s11 :|: s11 >= 0, s11 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s12 :|: s12 >= 0, s12 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ z' }-> 1 + s13 :|: s13 >= 0, s13 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 3 + s22 }-> 1 + s23 :|: s22 >= 0, s22 <= z - 2 + (z' - 2), s23 >= 0, s23 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 3 + s20 }-> 1 + s46 :|: s44 >= 0, s44 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s45 >= 0, s45 <= s44 + s19, s46 >= 0, s46 <= 0, s19 >= 0, s19 <= z - 2 + (z' - 2), s20 >= 0, s20 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + s49 :|: s47 >= 0, s47 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s48 >= 0, s48 <= s47 + s21, s49 >= 0, s49 <= 0, s21 >= 0, s21 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z }-> 1 + s7 :|: s7 >= 0, s7 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s9 :|: s9 >= 0, s9 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ z }-> 1 + s' + *'(z - 1, 0) :|: s' >= 0, s' <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s'' + *'(0, 0) :|: s'' >= 0, s'' <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s1 + *'(z - 1, 0) :|: s1 >= 0, s1 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 3 + s17 }-> 1 + s18 + *'(1 + (z - 2), 1 + (z' - 2)) :|: s17 >= 0, s17 <= z - 2 + (z' - 2), s18 >= 0, s18 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z' }-> 1 + s2 + *'(0, z' - 1) :|: s2 >= 0, s2 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s3 + *'(0, z' - 1) :|: s3 >= 0, s3 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s4 + *'(z - 1, z' - 1) :|: s4 >= 0, s4 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 3 + s15 }-> 1 + s40 + *'(1 + (z - 2), 1 + (z' - 2)) :|: s38 >= 0, s38 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s39 >= 0, s39 <= s38 + s14, s40 >= 0, s40 <= 0, s14 >= 0, s14 <= z - 2 + (z' - 2), s15 >= 0, s15 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + s43 + *'(1 + (z - 2), 1 + (z' - 2)) :|: s41 >= 0, s41 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s42 >= 0, s42 <= s41 + s16, s43 >= 0, s43 <= 0, s16 >= 0, s16 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   +'(z, z') -{ z' }-> 1 + s :|: s >= 0, s <= 0, z' - 1 >= 0, z - 1 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, s65) + PROD(1 + z02 + z12) :|: s64 >= 0, s64 <= inf, s65 >= 0, s65 <= 8 * z02 + 2 * s64 + 3 * (z02 * z02) + 3 * (s64 * z02) + 7, z = 1 + z0 + (1 + z02 + z12), z02 >= 0, z0 >= 0, z12 >= 0
   PROD(z) -{ 1 }-> 1 + *'(z0, 0) + PROD(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   PROD(z) -{ 1 }-> 1 + *'(z - 1, 1 + 0) + PROD(0) :|: z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + s5 + SUM(0) :|: s5 >= 0, s5 <= 0, z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + s6 + SUM(z1) :|: s6 >= 0, s6 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 1 + s59 }-> 1 + s60 + SUM(1 + z01 + z11) :|: s58 >= 0, s58 <= z11, s59 >= 0, s59 <= z01 + s58, s60 >= 0, s60 <= 0, z11 >= 0, z01 >= 0, z0 >= 0, z = 1 + z0 + (1 + z01 + z11)
   plus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + (1 + s24) :|: s24 >= 0, s24 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   prod(z) -{ 0 }-> s56 :|: s56 >= 0, s56 <= 8 * (z - 1) + 2 * (1 + 0) + 3 * ((z - 1) * (z - 1)) + 3 * ((1 + 0) * (z - 1)) + 7, z - 1 >= 0
   prod(z) -{ 0 }-> s57 :|: s57 >= 0, s57 <= 8 * z0 + 2 * 0 + 3 * (z0 * z0) + 3 * (0 * z0) + 7, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   prod(z) -{ 0 }-> s68 :|: s66 >= 0, s66 <= inf', s67 >= 0, s67 <= 8 * z08 + 2 * s66 + 3 * (z08 * z08) + 3 * (s66 * z08) + 7, s68 >= 0, s68 <= 8 * z0 + 2 * s67 + 3 * (z0 * z0) + 3 * (s67 * z0) + 7, z08 >= 0, z18 >= 0, z0 >= 0, z = 1 + z0 + (1 + z08 + z18)
   prod(z) -{ 0 }-> 0 :|: z >= 0
   prod(z) -{ 0 }-> 1 + 0 :|: z = 0
   sum(z) -{ 0 }-> s36 :|: s36 >= 0, s36 <= z - 1 + 0, z - 1 >= 0
   sum(z) -{ 0 }-> s37 :|: s37 >= 0, s37 <= z0 + 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   sum(z) -{ 0 }-> s63 :|: s61 >= 0, s61 <= z17, s62 >= 0, s62 <= z07 + s61, s63 >= 0, s63 <= z0 + s62, z = 1 + z0 + (1 + z07 + z17), z07 >= 0, z17 >= 0, z0 >= 0
   sum(z) -{ 0 }-> 0 :|: z = 0
   sum(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 0 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   times(z, z') -{ 0 }-> 1 + s25 :|: s25 >= 0, s25 <= 0 + (z - 1), z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s26 :|: s26 >= 0, s26 <= 0 + 0, z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 0 }-> 1 + s27 :|: s27 >= 0, s27 <= 0 + 0, z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s28 :|: s28 >= 0, s28 <= 0 + (z' - 1), z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s29 :|: s29 >= 0, s29 <= 0 + 0, z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s34 :|: s33 >= 0, s33 <= z - 2 + (z' - 2), s34 >= 0, s34 <= 0 + (1 + (1 + s33)), z - 2 >= 0, z' - 2 >= 0
   times(z, z') -{ 0 }-> 1 + s35 :|: s35 >= 0, s35 <= 0 + 0, z' - 1 >= 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s52 :|: s50 >= 0, s50 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s51 >= 0, s51 <= s50 + s30, s52 >= 0, s52 <= 1 + s51 + (1 + (1 + s31)), s30 >= 0, s30 <= z - 2 + (z' - 2), s31 >= 0, s31 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0
   times(z, z') -{ 0 }-> 1 + s55 :|: s53 >= 0, s53 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s54 >= 0, s54 <= s53 + s32, s55 >= 0, s55 <= 1 + s54 + 0, s32 >= 0, s32 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0

Function symbols to be analyzed: {SUM}, {PROD}
Previous analysis results are:
  +': runtime: O(n^1) [z'], size: O(1) [0]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  times: runtime: O(1) [0], size: O(n^2) [7 + 8*z + 3*z*z' + 3*z^2 + 2*z']
  sum: runtime: O(1) [0], size: O(n^1) [z]
  prod: runtime: O(1) [0], size: INF
  *': runtime: O(n^2) [2 + 3*z + 2*z*z' + z^2 + 3*z' + z'^2], size: O(n^1) [z']

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

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

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

   *'(z, z') -{ z' }-> 1 + s10 :|: s10 >= 0, s10 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s11 :|: s11 >= 0, s11 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s12 :|: s12 >= 0, s12 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ z' }-> 1 + s13 :|: s13 >= 0, s13 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 3 + s22 }-> 1 + s23 :|: s22 >= 0, s22 <= z - 2 + (z' - 2), s23 >= 0, s23 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 3 + s20 }-> 1 + s46 :|: s44 >= 0, s44 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s45 >= 0, s45 <= s44 + s19, s46 >= 0, s46 <= 0, s19 >= 0, s19 <= z - 2 + (z' - 2), s20 >= 0, s20 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + s49 :|: s47 >= 0, s47 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s48 >= 0, s48 <= s47 + s21, s49 >= 0, s49 <= 0, s21 >= 0, s21 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z }-> 1 + s7 :|: s7 >= 0, s7 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s9 :|: s9 >= 0, s9 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 2*z + z^2 }-> 1 + s' + s69 :|: s69 >= 0, s69 <= 0, s' >= 0, s' <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 3 }-> 1 + s'' + s70 :|: s70 >= 0, s70 <= 0, s'' >= 0, s'' <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 + z + z^2 }-> 1 + s1 + s71 :|: s71 >= 0, s71 <= 0, s1 >= 0, s1 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 3 + s17 + -1*z + 2*z*z' + z^2 + -1*z' + z'^2 }-> 1 + s18 + s76 :|: s76 >= 0, s76 <= 1 + (z' - 2), s17 >= 0, s17 <= z - 2 + (z' - 2), s18 >= 0, s18 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 2*z' + z'^2 }-> 1 + s2 + s72 :|: s72 >= 0, s72 <= z' - 1, s2 >= 0, s2 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 + z' + z'^2 }-> 1 + s3 + s73 :|: s73 >= 0, s73 <= z' - 1, s3 >= 0, s3 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 + -1*z + 2*z*z' + z^2 + -1*z' + z'^2 }-> 1 + s4 + s77 :|: s77 >= 0, s77 <= z' - 1, s4 >= 0, s4 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 3 + s15 + -1*z + 2*z*z' + z^2 + -1*z' + z'^2 }-> 1 + s40 + s74 :|: s74 >= 0, s74 <= 1 + (z' - 2), s38 >= 0, s38 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s39 >= 0, s39 <= s38 + s14, s40 >= 0, s40 <= 0, s14 >= 0, s14 <= z - 2 + (z' - 2), s15 >= 0, s15 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 + -1*z + 2*z*z' + z^2 + -1*z' + z'^2 }-> 1 + s43 + s75 :|: s75 >= 0, s75 <= 1 + (z' - 2), s41 >= 0, s41 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s42 >= 0, s42 <= s41 + s16, s43 >= 0, s43 <= 0, s16 >= 0, s16 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   +'(z, z') -{ z' }-> 1 + s :|: s >= 0, s <= 0, z' - 1 >= 0, z - 1 >= 0
   PROD(z) -{ 3 + 3*z + z^2 }-> 1 + s78 + PROD(0) :|: s78 >= 0, s78 <= 1 + 0, z - 1 >= 0
   PROD(z) -{ 3 + 3*s65 + 2*s65*z0 + s65^2 + 3*z0 + z0^2 }-> 1 + s79 + PROD(1 + z02 + z12) :|: s79 >= 0, s79 <= s65, s64 >= 0, s64 <= inf, s65 >= 0, s65 <= 8 * z02 + 2 * s64 + 3 * (z02 * z02) + 3 * (s64 * z02) + 7, z = 1 + z0 + (1 + z02 + z12), z02 >= 0, z0 >= 0, z12 >= 0
   PROD(z) -{ 3 + 3*z0 + z0^2 }-> 1 + s80 + PROD(z1) :|: s80 >= 0, s80 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 1 }-> 1 + s5 + SUM(0) :|: s5 >= 0, s5 <= 0, z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + s6 + SUM(z1) :|: s6 >= 0, s6 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 1 + s59 }-> 1 + s60 + SUM(1 + z01 + z11) :|: s58 >= 0, s58 <= z11, s59 >= 0, s59 <= z01 + s58, s60 >= 0, s60 <= 0, z11 >= 0, z01 >= 0, z0 >= 0, z = 1 + z0 + (1 + z01 + z11)
   plus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + (1 + s24) :|: s24 >= 0, s24 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   prod(z) -{ 0 }-> s56 :|: s56 >= 0, s56 <= 8 * (z - 1) + 2 * (1 + 0) + 3 * ((z - 1) * (z - 1)) + 3 * ((1 + 0) * (z - 1)) + 7, z - 1 >= 0
   prod(z) -{ 0 }-> s57 :|: s57 >= 0, s57 <= 8 * z0 + 2 * 0 + 3 * (z0 * z0) + 3 * (0 * z0) + 7, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   prod(z) -{ 0 }-> s68 :|: s66 >= 0, s66 <= inf', s67 >= 0, s67 <= 8 * z08 + 2 * s66 + 3 * (z08 * z08) + 3 * (s66 * z08) + 7, s68 >= 0, s68 <= 8 * z0 + 2 * s67 + 3 * (z0 * z0) + 3 * (s67 * z0) + 7, z08 >= 0, z18 >= 0, z0 >= 0, z = 1 + z0 + (1 + z08 + z18)
   prod(z) -{ 0 }-> 0 :|: z >= 0
   prod(z) -{ 0 }-> 1 + 0 :|: z = 0
   sum(z) -{ 0 }-> s36 :|: s36 >= 0, s36 <= z - 1 + 0, z - 1 >= 0
   sum(z) -{ 0 }-> s37 :|: s37 >= 0, s37 <= z0 + 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   sum(z) -{ 0 }-> s63 :|: s61 >= 0, s61 <= z17, s62 >= 0, s62 <= z07 + s61, s63 >= 0, s63 <= z0 + s62, z = 1 + z0 + (1 + z07 + z17), z07 >= 0, z17 >= 0, z0 >= 0
   sum(z) -{ 0 }-> 0 :|: z = 0
   sum(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 0 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   times(z, z') -{ 0 }-> 1 + s25 :|: s25 >= 0, s25 <= 0 + (z - 1), z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s26 :|: s26 >= 0, s26 <= 0 + 0, z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 0 }-> 1 + s27 :|: s27 >= 0, s27 <= 0 + 0, z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s28 :|: s28 >= 0, s28 <= 0 + (z' - 1), z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s29 :|: s29 >= 0, s29 <= 0 + 0, z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s34 :|: s33 >= 0, s33 <= z - 2 + (z' - 2), s34 >= 0, s34 <= 0 + (1 + (1 + s33)), z - 2 >= 0, z' - 2 >= 0
   times(z, z') -{ 0 }-> 1 + s35 :|: s35 >= 0, s35 <= 0 + 0, z' - 1 >= 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s52 :|: s50 >= 0, s50 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s51 >= 0, s51 <= s50 + s30, s52 >= 0, s52 <= 1 + s51 + (1 + (1 + s31)), s30 >= 0, s30 <= z - 2 + (z' - 2), s31 >= 0, s31 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0
   times(z, z') -{ 0 }-> 1 + s55 :|: s53 >= 0, s53 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s54 >= 0, s54 <= s53 + s32, s55 >= 0, s55 <= 1 + s54 + 0, s32 >= 0, s32 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0

Function symbols to be analyzed: {SUM}, {PROD}
Previous analysis results are:
  +': runtime: O(n^1) [z'], size: O(1) [0]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  times: runtime: O(1) [0], size: O(n^2) [7 + 8*z + 3*z*z' + 3*z^2 + 2*z']
  sum: runtime: O(1) [0], size: O(n^1) [z]
  prod: runtime: O(1) [0], size: INF
  *': runtime: O(n^2) [2 + 3*z + 2*z*z' + z^2 + 3*z' + z'^2], size: O(n^1) [z']

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

(87) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   *'(z, z') -{ z' }-> 1 + s10 :|: s10 >= 0, s10 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s11 :|: s11 >= 0, s11 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s12 :|: s12 >= 0, s12 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ z' }-> 1 + s13 :|: s13 >= 0, s13 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 3 + s22 }-> 1 + s23 :|: s22 >= 0, s22 <= z - 2 + (z' - 2), s23 >= 0, s23 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 3 + s20 }-> 1 + s46 :|: s44 >= 0, s44 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s45 >= 0, s45 <= s44 + s19, s46 >= 0, s46 <= 0, s19 >= 0, s19 <= z - 2 + (z' - 2), s20 >= 0, s20 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + s49 :|: s47 >= 0, s47 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s48 >= 0, s48 <= s47 + s21, s49 >= 0, s49 <= 0, s21 >= 0, s21 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z }-> 1 + s7 :|: s7 >= 0, s7 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s9 :|: s9 >= 0, s9 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 2*z + z^2 }-> 1 + s' + s69 :|: s69 >= 0, s69 <= 0, s' >= 0, s' <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 3 }-> 1 + s'' + s70 :|: s70 >= 0, s70 <= 0, s'' >= 0, s'' <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 + z + z^2 }-> 1 + s1 + s71 :|: s71 >= 0, s71 <= 0, s1 >= 0, s1 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 3 + s17 + -1*z + 2*z*z' + z^2 + -1*z' + z'^2 }-> 1 + s18 + s76 :|: s76 >= 0, s76 <= 1 + (z' - 2), s17 >= 0, s17 <= z - 2 + (z' - 2), s18 >= 0, s18 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 2*z' + z'^2 }-> 1 + s2 + s72 :|: s72 >= 0, s72 <= z' - 1, s2 >= 0, s2 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 + z' + z'^2 }-> 1 + s3 + s73 :|: s73 >= 0, s73 <= z' - 1, s3 >= 0, s3 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 + -1*z + 2*z*z' + z^2 + -1*z' + z'^2 }-> 1 + s4 + s77 :|: s77 >= 0, s77 <= z' - 1, s4 >= 0, s4 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 3 + s15 + -1*z + 2*z*z' + z^2 + -1*z' + z'^2 }-> 1 + s40 + s74 :|: s74 >= 0, s74 <= 1 + (z' - 2), s38 >= 0, s38 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s39 >= 0, s39 <= s38 + s14, s40 >= 0, s40 <= 0, s14 >= 0, s14 <= z - 2 + (z' - 2), s15 >= 0, s15 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 + -1*z + 2*z*z' + z^2 + -1*z' + z'^2 }-> 1 + s43 + s75 :|: s75 >= 0, s75 <= 1 + (z' - 2), s41 >= 0, s41 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s42 >= 0, s42 <= s41 + s16, s43 >= 0, s43 <= 0, s16 >= 0, s16 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   +'(z, z') -{ z' }-> 1 + s :|: s >= 0, s <= 0, z' - 1 >= 0, z - 1 >= 0
   PROD(z) -{ 3 + 3*z + z^2 }-> 1 + s78 + PROD(0) :|: s78 >= 0, s78 <= 1 + 0, z - 1 >= 0
   PROD(z) -{ 3 + 3*s65 + 2*s65*z0 + s65^2 + 3*z0 + z0^2 }-> 1 + s79 + PROD(1 + z02 + z12) :|: s79 >= 0, s79 <= s65, s64 >= 0, s64 <= inf, s65 >= 0, s65 <= 8 * z02 + 2 * s64 + 3 * (z02 * z02) + 3 * (s64 * z02) + 7, z = 1 + z0 + (1 + z02 + z12), z02 >= 0, z0 >= 0, z12 >= 0
   PROD(z) -{ 3 + 3*z0 + z0^2 }-> 1 + s80 + PROD(z1) :|: s80 >= 0, s80 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 1 }-> 1 + s5 + SUM(0) :|: s5 >= 0, s5 <= 0, z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + s6 + SUM(z1) :|: s6 >= 0, s6 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 1 + s59 }-> 1 + s60 + SUM(1 + z01 + z11) :|: s58 >= 0, s58 <= z11, s59 >= 0, s59 <= z01 + s58, s60 >= 0, s60 <= 0, z11 >= 0, z01 >= 0, z0 >= 0, z = 1 + z0 + (1 + z01 + z11)
   plus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + (1 + s24) :|: s24 >= 0, s24 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   prod(z) -{ 0 }-> s56 :|: s56 >= 0, s56 <= 8 * (z - 1) + 2 * (1 + 0) + 3 * ((z - 1) * (z - 1)) + 3 * ((1 + 0) * (z - 1)) + 7, z - 1 >= 0
   prod(z) -{ 0 }-> s57 :|: s57 >= 0, s57 <= 8 * z0 + 2 * 0 + 3 * (z0 * z0) + 3 * (0 * z0) + 7, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   prod(z) -{ 0 }-> s68 :|: s66 >= 0, s66 <= inf', s67 >= 0, s67 <= 8 * z08 + 2 * s66 + 3 * (z08 * z08) + 3 * (s66 * z08) + 7, s68 >= 0, s68 <= 8 * z0 + 2 * s67 + 3 * (z0 * z0) + 3 * (s67 * z0) + 7, z08 >= 0, z18 >= 0, z0 >= 0, z = 1 + z0 + (1 + z08 + z18)
   prod(z) -{ 0 }-> 0 :|: z >= 0
   prod(z) -{ 0 }-> 1 + 0 :|: z = 0
   sum(z) -{ 0 }-> s36 :|: s36 >= 0, s36 <= z - 1 + 0, z - 1 >= 0
   sum(z) -{ 0 }-> s37 :|: s37 >= 0, s37 <= z0 + 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   sum(z) -{ 0 }-> s63 :|: s61 >= 0, s61 <= z17, s62 >= 0, s62 <= z07 + s61, s63 >= 0, s63 <= z0 + s62, z = 1 + z0 + (1 + z07 + z17), z07 >= 0, z17 >= 0, z0 >= 0
   sum(z) -{ 0 }-> 0 :|: z = 0
   sum(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 0 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   times(z, z') -{ 0 }-> 1 + s25 :|: s25 >= 0, s25 <= 0 + (z - 1), z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s26 :|: s26 >= 0, s26 <= 0 + 0, z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 0 }-> 1 + s27 :|: s27 >= 0, s27 <= 0 + 0, z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s28 :|: s28 >= 0, s28 <= 0 + (z' - 1), z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s29 :|: s29 >= 0, s29 <= 0 + 0, z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s34 :|: s33 >= 0, s33 <= z - 2 + (z' - 2), s34 >= 0, s34 <= 0 + (1 + (1 + s33)), z - 2 >= 0, z' - 2 >= 0
   times(z, z') -{ 0 }-> 1 + s35 :|: s35 >= 0, s35 <= 0 + 0, z' - 1 >= 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s52 :|: s50 >= 0, s50 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s51 >= 0, s51 <= s50 + s30, s52 >= 0, s52 <= 1 + s51 + (1 + (1 + s31)), s30 >= 0, s30 <= z - 2 + (z' - 2), s31 >= 0, s31 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0
   times(z, z') -{ 0 }-> 1 + s55 :|: s53 >= 0, s53 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s54 >= 0, s54 <= s53 + s32, s55 >= 0, s55 <= 1 + s54 + 0, s32 >= 0, s32 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0

Function symbols to be analyzed: {SUM}, {PROD}
Previous analysis results are:
  +': runtime: O(n^1) [z'], size: O(1) [0]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  times: runtime: O(1) [0], size: O(n^2) [7 + 8*z + 3*z*z' + 3*z^2 + 2*z']
  sum: runtime: O(1) [0], size: O(n^1) [z]
  prod: runtime: O(1) [0], size: INF
  *': runtime: O(n^2) [2 + 3*z + 2*z*z' + z^2 + 3*z' + z'^2], size: O(n^1) [z']
  SUM: runtime: ?, size: O(1) [0]

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

(89) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   *'(z, z') -{ z' }-> 1 + s10 :|: s10 >= 0, s10 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s11 :|: s11 >= 0, s11 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s12 :|: s12 >= 0, s12 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ z' }-> 1 + s13 :|: s13 >= 0, s13 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 3 + s22 }-> 1 + s23 :|: s22 >= 0, s22 <= z - 2 + (z' - 2), s23 >= 0, s23 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 3 + s20 }-> 1 + s46 :|: s44 >= 0, s44 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s45 >= 0, s45 <= s44 + s19, s46 >= 0, s46 <= 0, s19 >= 0, s19 <= z - 2 + (z' - 2), s20 >= 0, s20 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + s49 :|: s47 >= 0, s47 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s48 >= 0, s48 <= s47 + s21, s49 >= 0, s49 <= 0, s21 >= 0, s21 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z }-> 1 + s7 :|: s7 >= 0, s7 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s9 :|: s9 >= 0, s9 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 2*z + z^2 }-> 1 + s' + s69 :|: s69 >= 0, s69 <= 0, s' >= 0, s' <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 3 }-> 1 + s'' + s70 :|: s70 >= 0, s70 <= 0, s'' >= 0, s'' <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 + z + z^2 }-> 1 + s1 + s71 :|: s71 >= 0, s71 <= 0, s1 >= 0, s1 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 3 + s17 + -1*z + 2*z*z' + z^2 + -1*z' + z'^2 }-> 1 + s18 + s76 :|: s76 >= 0, s76 <= 1 + (z' - 2), s17 >= 0, s17 <= z - 2 + (z' - 2), s18 >= 0, s18 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 2*z' + z'^2 }-> 1 + s2 + s72 :|: s72 >= 0, s72 <= z' - 1, s2 >= 0, s2 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 + z' + z'^2 }-> 1 + s3 + s73 :|: s73 >= 0, s73 <= z' - 1, s3 >= 0, s3 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 + -1*z + 2*z*z' + z^2 + -1*z' + z'^2 }-> 1 + s4 + s77 :|: s77 >= 0, s77 <= z' - 1, s4 >= 0, s4 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 3 + s15 + -1*z + 2*z*z' + z^2 + -1*z' + z'^2 }-> 1 + s40 + s74 :|: s74 >= 0, s74 <= 1 + (z' - 2), s38 >= 0, s38 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s39 >= 0, s39 <= s38 + s14, s40 >= 0, s40 <= 0, s14 >= 0, s14 <= z - 2 + (z' - 2), s15 >= 0, s15 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 + -1*z + 2*z*z' + z^2 + -1*z' + z'^2 }-> 1 + s43 + s75 :|: s75 >= 0, s75 <= 1 + (z' - 2), s41 >= 0, s41 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s42 >= 0, s42 <= s41 + s16, s43 >= 0, s43 <= 0, s16 >= 0, s16 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   +'(z, z') -{ z' }-> 1 + s :|: s >= 0, s <= 0, z' - 1 >= 0, z - 1 >= 0
   PROD(z) -{ 3 + 3*z + z^2 }-> 1 + s78 + PROD(0) :|: s78 >= 0, s78 <= 1 + 0, z - 1 >= 0
   PROD(z) -{ 3 + 3*s65 + 2*s65*z0 + s65^2 + 3*z0 + z0^2 }-> 1 + s79 + PROD(1 + z02 + z12) :|: s79 >= 0, s79 <= s65, s64 >= 0, s64 <= inf, s65 >= 0, s65 <= 8 * z02 + 2 * s64 + 3 * (z02 * z02) + 3 * (s64 * z02) + 7, z = 1 + z0 + (1 + z02 + z12), z02 >= 0, z0 >= 0, z12 >= 0
   PROD(z) -{ 3 + 3*z0 + z0^2 }-> 1 + s80 + PROD(z1) :|: s80 >= 0, s80 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 1 }-> 1 + s5 + SUM(0) :|: s5 >= 0, s5 <= 0, z - 1 >= 0
   SUM(z) -{ 1 }-> 1 + s6 + SUM(z1) :|: s6 >= 0, s6 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 1 + s59 }-> 1 + s60 + SUM(1 + z01 + z11) :|: s58 >= 0, s58 <= z11, s59 >= 0, s59 <= z01 + s58, s60 >= 0, s60 <= 0, z11 >= 0, z01 >= 0, z0 >= 0, z = 1 + z0 + (1 + z01 + z11)
   plus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + (1 + s24) :|: s24 >= 0, s24 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   prod(z) -{ 0 }-> s56 :|: s56 >= 0, s56 <= 8 * (z - 1) + 2 * (1 + 0) + 3 * ((z - 1) * (z - 1)) + 3 * ((1 + 0) * (z - 1)) + 7, z - 1 >= 0
   prod(z) -{ 0 }-> s57 :|: s57 >= 0, s57 <= 8 * z0 + 2 * 0 + 3 * (z0 * z0) + 3 * (0 * z0) + 7, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   prod(z) -{ 0 }-> s68 :|: s66 >= 0, s66 <= inf', s67 >= 0, s67 <= 8 * z08 + 2 * s66 + 3 * (z08 * z08) + 3 * (s66 * z08) + 7, s68 >= 0, s68 <= 8 * z0 + 2 * s67 + 3 * (z0 * z0) + 3 * (s67 * z0) + 7, z08 >= 0, z18 >= 0, z0 >= 0, z = 1 + z0 + (1 + z08 + z18)
   prod(z) -{ 0 }-> 0 :|: z >= 0
   prod(z) -{ 0 }-> 1 + 0 :|: z = 0
   sum(z) -{ 0 }-> s36 :|: s36 >= 0, s36 <= z - 1 + 0, z - 1 >= 0
   sum(z) -{ 0 }-> s37 :|: s37 >= 0, s37 <= z0 + 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   sum(z) -{ 0 }-> s63 :|: s61 >= 0, s61 <= z17, s62 >= 0, s62 <= z07 + s61, s63 >= 0, s63 <= z0 + s62, z = 1 + z0 + (1 + z07 + z17), z07 >= 0, z17 >= 0, z0 >= 0
   sum(z) -{ 0 }-> 0 :|: z = 0
   sum(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 0 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   times(z, z') -{ 0 }-> 1 + s25 :|: s25 >= 0, s25 <= 0 + (z - 1), z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s26 :|: s26 >= 0, s26 <= 0 + 0, z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 0 }-> 1 + s27 :|: s27 >= 0, s27 <= 0 + 0, z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s28 :|: s28 >= 0, s28 <= 0 + (z' - 1), z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s29 :|: s29 >= 0, s29 <= 0 + 0, z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s34 :|: s33 >= 0, s33 <= z - 2 + (z' - 2), s34 >= 0, s34 <= 0 + (1 + (1 + s33)), z - 2 >= 0, z' - 2 >= 0
   times(z, z') -{ 0 }-> 1 + s35 :|: s35 >= 0, s35 <= 0 + 0, z' - 1 >= 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s52 :|: s50 >= 0, s50 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s51 >= 0, s51 <= s50 + s30, s52 >= 0, s52 <= 1 + s51 + (1 + (1 + s31)), s30 >= 0, s30 <= z - 2 + (z' - 2), s31 >= 0, s31 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0
   times(z, z') -{ 0 }-> 1 + s55 :|: s53 >= 0, s53 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s54 >= 0, s54 <= s53 + s32, s55 >= 0, s55 <= 1 + s54 + 0, s32 >= 0, s32 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0

Function symbols to be analyzed: {PROD}
Previous analysis results are:
  +': runtime: O(n^1) [z'], size: O(1) [0]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  times: runtime: O(1) [0], size: O(n^2) [7 + 8*z + 3*z*z' + 3*z^2 + 2*z']
  sum: runtime: O(1) [0], size: O(n^1) [z]
  prod: runtime: O(1) [0], size: INF
  *': runtime: O(n^2) [2 + 3*z + 2*z*z' + z^2 + 3*z' + z'^2], size: O(n^1) [z']
  SUM: runtime: O(n^2) [z + z^2], size: O(1) [0]

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

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

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

   *'(z, z') -{ z' }-> 1 + s10 :|: s10 >= 0, s10 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s11 :|: s11 >= 0, s11 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s12 :|: s12 >= 0, s12 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ z' }-> 1 + s13 :|: s13 >= 0, s13 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 3 + s22 }-> 1 + s23 :|: s22 >= 0, s22 <= z - 2 + (z' - 2), s23 >= 0, s23 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 3 + s20 }-> 1 + s46 :|: s44 >= 0, s44 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s45 >= 0, s45 <= s44 + s19, s46 >= 0, s46 <= 0, s19 >= 0, s19 <= z - 2 + (z' - 2), s20 >= 0, s20 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + s49 :|: s47 >= 0, s47 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s48 >= 0, s48 <= s47 + s21, s49 >= 0, s49 <= 0, s21 >= 0, s21 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z }-> 1 + s7 :|: s7 >= 0, s7 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s9 :|: s9 >= 0, s9 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 2*z + z^2 }-> 1 + s' + s69 :|: s69 >= 0, s69 <= 0, s' >= 0, s' <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 3 }-> 1 + s'' + s70 :|: s70 >= 0, s70 <= 0, s'' >= 0, s'' <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 + z + z^2 }-> 1 + s1 + s71 :|: s71 >= 0, s71 <= 0, s1 >= 0, s1 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 3 + s17 + -1*z + 2*z*z' + z^2 + -1*z' + z'^2 }-> 1 + s18 + s76 :|: s76 >= 0, s76 <= 1 + (z' - 2), s17 >= 0, s17 <= z - 2 + (z' - 2), s18 >= 0, s18 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 2*z' + z'^2 }-> 1 + s2 + s72 :|: s72 >= 0, s72 <= z' - 1, s2 >= 0, s2 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 + z' + z'^2 }-> 1 + s3 + s73 :|: s73 >= 0, s73 <= z' - 1, s3 >= 0, s3 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 + -1*z + 2*z*z' + z^2 + -1*z' + z'^2 }-> 1 + s4 + s77 :|: s77 >= 0, s77 <= z' - 1, s4 >= 0, s4 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 3 + s15 + -1*z + 2*z*z' + z^2 + -1*z' + z'^2 }-> 1 + s40 + s74 :|: s74 >= 0, s74 <= 1 + (z' - 2), s38 >= 0, s38 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s39 >= 0, s39 <= s38 + s14, s40 >= 0, s40 <= 0, s14 >= 0, s14 <= z - 2 + (z' - 2), s15 >= 0, s15 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 + -1*z + 2*z*z' + z^2 + -1*z' + z'^2 }-> 1 + s43 + s75 :|: s75 >= 0, s75 <= 1 + (z' - 2), s41 >= 0, s41 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s42 >= 0, s42 <= s41 + s16, s43 >= 0, s43 <= 0, s16 >= 0, s16 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   +'(z, z') -{ z' }-> 1 + s :|: s >= 0, s <= 0, z' - 1 >= 0, z - 1 >= 0
   PROD(z) -{ 3 + 3*z + z^2 }-> 1 + s78 + PROD(0) :|: s78 >= 0, s78 <= 1 + 0, z - 1 >= 0
   PROD(z) -{ 3 + 3*s65 + 2*s65*z0 + s65^2 + 3*z0 + z0^2 }-> 1 + s79 + PROD(1 + z02 + z12) :|: s79 >= 0, s79 <= s65, s64 >= 0, s64 <= inf, s65 >= 0, s65 <= 8 * z02 + 2 * s64 + 3 * (z02 * z02) + 3 * (s64 * z02) + 7, z = 1 + z0 + (1 + z02 + z12), z02 >= 0, z0 >= 0, z12 >= 0
   PROD(z) -{ 3 + 3*z0 + z0^2 }-> 1 + s80 + PROD(z1) :|: s80 >= 0, s80 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 1 }-> 1 + s5 + s81 :|: s81 >= 0, s81 <= 0, s5 >= 0, s5 <= 0, z - 1 >= 0
   SUM(z) -{ 1 + z1 + z1^2 }-> 1 + s6 + s83 :|: s83 >= 0, s83 <= 0, s6 >= 0, s6 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 3 + s59 + 3*z01 + 2*z01*z11 + z01^2 + 3*z11 + z11^2 }-> 1 + s60 + s82 :|: s82 >= 0, s82 <= 0, s58 >= 0, s58 <= z11, s59 >= 0, s59 <= z01 + s58, s60 >= 0, s60 <= 0, z11 >= 0, z01 >= 0, z0 >= 0, z = 1 + z0 + (1 + z01 + z11)
   plus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + (1 + s24) :|: s24 >= 0, s24 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   prod(z) -{ 0 }-> s56 :|: s56 >= 0, s56 <= 8 * (z - 1) + 2 * (1 + 0) + 3 * ((z - 1) * (z - 1)) + 3 * ((1 + 0) * (z - 1)) + 7, z - 1 >= 0
   prod(z) -{ 0 }-> s57 :|: s57 >= 0, s57 <= 8 * z0 + 2 * 0 + 3 * (z0 * z0) + 3 * (0 * z0) + 7, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   prod(z) -{ 0 }-> s68 :|: s66 >= 0, s66 <= inf', s67 >= 0, s67 <= 8 * z08 + 2 * s66 + 3 * (z08 * z08) + 3 * (s66 * z08) + 7, s68 >= 0, s68 <= 8 * z0 + 2 * s67 + 3 * (z0 * z0) + 3 * (s67 * z0) + 7, z08 >= 0, z18 >= 0, z0 >= 0, z = 1 + z0 + (1 + z08 + z18)
   prod(z) -{ 0 }-> 0 :|: z >= 0
   prod(z) -{ 0 }-> 1 + 0 :|: z = 0
   sum(z) -{ 0 }-> s36 :|: s36 >= 0, s36 <= z - 1 + 0, z - 1 >= 0
   sum(z) -{ 0 }-> s37 :|: s37 >= 0, s37 <= z0 + 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   sum(z) -{ 0 }-> s63 :|: s61 >= 0, s61 <= z17, s62 >= 0, s62 <= z07 + s61, s63 >= 0, s63 <= z0 + s62, z = 1 + z0 + (1 + z07 + z17), z07 >= 0, z17 >= 0, z0 >= 0
   sum(z) -{ 0 }-> 0 :|: z = 0
   sum(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 0 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   times(z, z') -{ 0 }-> 1 + s25 :|: s25 >= 0, s25 <= 0 + (z - 1), z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s26 :|: s26 >= 0, s26 <= 0 + 0, z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 0 }-> 1 + s27 :|: s27 >= 0, s27 <= 0 + 0, z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s28 :|: s28 >= 0, s28 <= 0 + (z' - 1), z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s29 :|: s29 >= 0, s29 <= 0 + 0, z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s34 :|: s33 >= 0, s33 <= z - 2 + (z' - 2), s34 >= 0, s34 <= 0 + (1 + (1 + s33)), z - 2 >= 0, z' - 2 >= 0
   times(z, z') -{ 0 }-> 1 + s35 :|: s35 >= 0, s35 <= 0 + 0, z' - 1 >= 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s52 :|: s50 >= 0, s50 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s51 >= 0, s51 <= s50 + s30, s52 >= 0, s52 <= 1 + s51 + (1 + (1 + s31)), s30 >= 0, s30 <= z - 2 + (z' - 2), s31 >= 0, s31 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0
   times(z, z') -{ 0 }-> 1 + s55 :|: s53 >= 0, s53 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s54 >= 0, s54 <= s53 + s32, s55 >= 0, s55 <= 1 + s54 + 0, s32 >= 0, s32 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0

Function symbols to be analyzed: {PROD}
Previous analysis results are:
  +': runtime: O(n^1) [z'], size: O(1) [0]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  times: runtime: O(1) [0], size: O(n^2) [7 + 8*z + 3*z*z' + 3*z^2 + 2*z']
  sum: runtime: O(1) [0], size: O(n^1) [z]
  prod: runtime: O(1) [0], size: INF
  *': runtime: O(n^2) [2 + 3*z + 2*z*z' + z^2 + 3*z' + z'^2], size: O(n^1) [z']
  SUM: runtime: O(n^2) [z + z^2], size: O(1) [0]

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

(93) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   *'(z, z') -{ z' }-> 1 + s10 :|: s10 >= 0, s10 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s11 :|: s11 >= 0, s11 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s12 :|: s12 >= 0, s12 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ z' }-> 1 + s13 :|: s13 >= 0, s13 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 3 + s22 }-> 1 + s23 :|: s22 >= 0, s22 <= z - 2 + (z' - 2), s23 >= 0, s23 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 3 + s20 }-> 1 + s46 :|: s44 >= 0, s44 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s45 >= 0, s45 <= s44 + s19, s46 >= 0, s46 <= 0, s19 >= 0, s19 <= z - 2 + (z' - 2), s20 >= 0, s20 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + s49 :|: s47 >= 0, s47 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s48 >= 0, s48 <= s47 + s21, s49 >= 0, s49 <= 0, s21 >= 0, s21 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z }-> 1 + s7 :|: s7 >= 0, s7 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s9 :|: s9 >= 0, s9 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 2*z + z^2 }-> 1 + s' + s69 :|: s69 >= 0, s69 <= 0, s' >= 0, s' <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 3 }-> 1 + s'' + s70 :|: s70 >= 0, s70 <= 0, s'' >= 0, s'' <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 + z + z^2 }-> 1 + s1 + s71 :|: s71 >= 0, s71 <= 0, s1 >= 0, s1 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 3 + s17 + -1*z + 2*z*z' + z^2 + -1*z' + z'^2 }-> 1 + s18 + s76 :|: s76 >= 0, s76 <= 1 + (z' - 2), s17 >= 0, s17 <= z - 2 + (z' - 2), s18 >= 0, s18 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 2*z' + z'^2 }-> 1 + s2 + s72 :|: s72 >= 0, s72 <= z' - 1, s2 >= 0, s2 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 + z' + z'^2 }-> 1 + s3 + s73 :|: s73 >= 0, s73 <= z' - 1, s3 >= 0, s3 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 + -1*z + 2*z*z' + z^2 + -1*z' + z'^2 }-> 1 + s4 + s77 :|: s77 >= 0, s77 <= z' - 1, s4 >= 0, s4 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 3 + s15 + -1*z + 2*z*z' + z^2 + -1*z' + z'^2 }-> 1 + s40 + s74 :|: s74 >= 0, s74 <= 1 + (z' - 2), s38 >= 0, s38 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s39 >= 0, s39 <= s38 + s14, s40 >= 0, s40 <= 0, s14 >= 0, s14 <= z - 2 + (z' - 2), s15 >= 0, s15 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 + -1*z + 2*z*z' + z^2 + -1*z' + z'^2 }-> 1 + s43 + s75 :|: s75 >= 0, s75 <= 1 + (z' - 2), s41 >= 0, s41 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s42 >= 0, s42 <= s41 + s16, s43 >= 0, s43 <= 0, s16 >= 0, s16 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   +'(z, z') -{ z' }-> 1 + s :|: s >= 0, s <= 0, z' - 1 >= 0, z - 1 >= 0
   PROD(z) -{ 3 + 3*z + z^2 }-> 1 + s78 + PROD(0) :|: s78 >= 0, s78 <= 1 + 0, z - 1 >= 0
   PROD(z) -{ 3 + 3*s65 + 2*s65*z0 + s65^2 + 3*z0 + z0^2 }-> 1 + s79 + PROD(1 + z02 + z12) :|: s79 >= 0, s79 <= s65, s64 >= 0, s64 <= inf, s65 >= 0, s65 <= 8 * z02 + 2 * s64 + 3 * (z02 * z02) + 3 * (s64 * z02) + 7, z = 1 + z0 + (1 + z02 + z12), z02 >= 0, z0 >= 0, z12 >= 0
   PROD(z) -{ 3 + 3*z0 + z0^2 }-> 1 + s80 + PROD(z1) :|: s80 >= 0, s80 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 1 }-> 1 + s5 + s81 :|: s81 >= 0, s81 <= 0, s5 >= 0, s5 <= 0, z - 1 >= 0
   SUM(z) -{ 1 + z1 + z1^2 }-> 1 + s6 + s83 :|: s83 >= 0, s83 <= 0, s6 >= 0, s6 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 3 + s59 + 3*z01 + 2*z01*z11 + z01^2 + 3*z11 + z11^2 }-> 1 + s60 + s82 :|: s82 >= 0, s82 <= 0, s58 >= 0, s58 <= z11, s59 >= 0, s59 <= z01 + s58, s60 >= 0, s60 <= 0, z11 >= 0, z01 >= 0, z0 >= 0, z = 1 + z0 + (1 + z01 + z11)
   plus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + (1 + s24) :|: s24 >= 0, s24 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   prod(z) -{ 0 }-> s56 :|: s56 >= 0, s56 <= 8 * (z - 1) + 2 * (1 + 0) + 3 * ((z - 1) * (z - 1)) + 3 * ((1 + 0) * (z - 1)) + 7, z - 1 >= 0
   prod(z) -{ 0 }-> s57 :|: s57 >= 0, s57 <= 8 * z0 + 2 * 0 + 3 * (z0 * z0) + 3 * (0 * z0) + 7, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   prod(z) -{ 0 }-> s68 :|: s66 >= 0, s66 <= inf', s67 >= 0, s67 <= 8 * z08 + 2 * s66 + 3 * (z08 * z08) + 3 * (s66 * z08) + 7, s68 >= 0, s68 <= 8 * z0 + 2 * s67 + 3 * (z0 * z0) + 3 * (s67 * z0) + 7, z08 >= 0, z18 >= 0, z0 >= 0, z = 1 + z0 + (1 + z08 + z18)
   prod(z) -{ 0 }-> 0 :|: z >= 0
   prod(z) -{ 0 }-> 1 + 0 :|: z = 0
   sum(z) -{ 0 }-> s36 :|: s36 >= 0, s36 <= z - 1 + 0, z - 1 >= 0
   sum(z) -{ 0 }-> s37 :|: s37 >= 0, s37 <= z0 + 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   sum(z) -{ 0 }-> s63 :|: s61 >= 0, s61 <= z17, s62 >= 0, s62 <= z07 + s61, s63 >= 0, s63 <= z0 + s62, z = 1 + z0 + (1 + z07 + z17), z07 >= 0, z17 >= 0, z0 >= 0
   sum(z) -{ 0 }-> 0 :|: z = 0
   sum(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 0 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   times(z, z') -{ 0 }-> 1 + s25 :|: s25 >= 0, s25 <= 0 + (z - 1), z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s26 :|: s26 >= 0, s26 <= 0 + 0, z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 0 }-> 1 + s27 :|: s27 >= 0, s27 <= 0 + 0, z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s28 :|: s28 >= 0, s28 <= 0 + (z' - 1), z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s29 :|: s29 >= 0, s29 <= 0 + 0, z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s34 :|: s33 >= 0, s33 <= z - 2 + (z' - 2), s34 >= 0, s34 <= 0 + (1 + (1 + s33)), z - 2 >= 0, z' - 2 >= 0
   times(z, z') -{ 0 }-> 1 + s35 :|: s35 >= 0, s35 <= 0 + 0, z' - 1 >= 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s52 :|: s50 >= 0, s50 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s51 >= 0, s51 <= s50 + s30, s52 >= 0, s52 <= 1 + s51 + (1 + (1 + s31)), s30 >= 0, s30 <= z - 2 + (z' - 2), s31 >= 0, s31 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0
   times(z, z') -{ 0 }-> 1 + s55 :|: s53 >= 0, s53 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s54 >= 0, s54 <= s53 + s32, s55 >= 0, s55 <= 1 + s54 + 0, s32 >= 0, s32 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0

Function symbols to be analyzed: {PROD}
Previous analysis results are:
  +': runtime: O(n^1) [z'], size: O(1) [0]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  times: runtime: O(1) [0], size: O(n^2) [7 + 8*z + 3*z*z' + 3*z^2 + 2*z']
  sum: runtime: O(1) [0], size: O(n^1) [z]
  prod: runtime: O(1) [0], size: INF
  *': runtime: O(n^2) [2 + 3*z + 2*z*z' + z^2 + 3*z' + z'^2], size: O(n^1) [z']
  SUM: runtime: O(n^2) [z + z^2], size: O(1) [0]
  PROD: runtime: ?, size: O(1) [0]

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

(95) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   *'(z, z') -{ z' }-> 1 + s10 :|: s10 >= 0, s10 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s11 :|: s11 >= 0, s11 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s12 :|: s12 >= 0, s12 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ z' }-> 1 + s13 :|: s13 >= 0, s13 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 3 + s22 }-> 1 + s23 :|: s22 >= 0, s22 <= z - 2 + (z' - 2), s23 >= 0, s23 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 3 + s20 }-> 1 + s46 :|: s44 >= 0, s44 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s45 >= 0, s45 <= s44 + s19, s46 >= 0, s46 <= 0, s19 >= 0, s19 <= z - 2 + (z' - 2), s20 >= 0, s20 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 }-> 1 + s49 :|: s47 >= 0, s47 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s48 >= 0, s48 <= s47 + s21, s49 >= 0, s49 <= 0, s21 >= 0, s21 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ z }-> 1 + s7 :|: s7 >= 0, s7 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 1 }-> 1 + s8 :|: s8 >= 0, s8 <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 }-> 1 + s9 :|: s9 >= 0, s9 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 2*z + z^2 }-> 1 + s' + s69 :|: s69 >= 0, s69 <= 0, s' >= 0, s' <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 3 }-> 1 + s'' + s70 :|: s70 >= 0, s70 <= 0, s'' >= 0, s'' <= 0, z = 1 + 0, z' = 1 + 0
   *'(z, z') -{ 1 + z + z^2 }-> 1 + s1 + s71 :|: s71 >= 0, s71 <= 0, s1 >= 0, s1 <= 0, z' = 1 + 0, z - 1 >= 0
   *'(z, z') -{ 3 + s17 + -1*z + 2*z*z' + z^2 + -1*z' + z'^2 }-> 1 + s18 + s76 :|: s76 >= 0, s76 <= 1 + (z' - 2), s17 >= 0, s17 <= z - 2 + (z' - 2), s18 >= 0, s18 <= 0, z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 2*z' + z'^2 }-> 1 + s2 + s72 :|: s72 >= 0, s72 <= z' - 1, s2 >= 0, s2 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 + z' + z'^2 }-> 1 + s3 + s73 :|: s73 >= 0, s73 <= z' - 1, s3 >= 0, s3 <= 0, z' - 1 >= 0, z = 1 + 0
   *'(z, z') -{ 1 + -1*z + 2*z*z' + z^2 + -1*z' + z'^2 }-> 1 + s4 + s77 :|: s77 >= 0, s77 <= z' - 1, s4 >= 0, s4 <= 0, z' - 1 >= 0, z - 1 >= 0
   *'(z, z') -{ 3 + s15 + -1*z + 2*z*z' + z^2 + -1*z' + z'^2 }-> 1 + s40 + s74 :|: s74 >= 0, s74 <= 1 + (z' - 2), s38 >= 0, s38 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s39 >= 0, s39 <= s38 + s14, s40 >= 0, s40 <= 0, s14 >= 0, s14 <= z - 2 + (z' - 2), s15 >= 0, s15 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   *'(z, z') -{ 1 + -1*z + 2*z*z' + z^2 + -1*z' + z'^2 }-> 1 + s43 + s75 :|: s75 >= 0, s75 <= 1 + (z' - 2), s41 >= 0, s41 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s42 >= 0, s42 <= s41 + s16, s43 >= 0, s43 <= 0, s16 >= 0, s16 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0
   +'(z, z') -{ z' }-> 1 + s :|: s >= 0, s <= 0, z' - 1 >= 0, z - 1 >= 0
   PROD(z) -{ 3 + 3*z + z^2 }-> 1 + s78 + PROD(0) :|: s78 >= 0, s78 <= 1 + 0, z - 1 >= 0
   PROD(z) -{ 3 + 3*s65 + 2*s65*z0 + s65^2 + 3*z0 + z0^2 }-> 1 + s79 + PROD(1 + z02 + z12) :|: s79 >= 0, s79 <= s65, s64 >= 0, s64 <= inf, s65 >= 0, s65 <= 8 * z02 + 2 * s64 + 3 * (z02 * z02) + 3 * (s64 * z02) + 7, z = 1 + z0 + (1 + z02 + z12), z02 >= 0, z0 >= 0, z12 >= 0
   PROD(z) -{ 3 + 3*z0 + z0^2 }-> 1 + s80 + PROD(z1) :|: s80 >= 0, s80 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 1 }-> 1 + s5 + s81 :|: s81 >= 0, s81 <= 0, s5 >= 0, s5 <= 0, z - 1 >= 0
   SUM(z) -{ 1 + z1 + z1^2 }-> 1 + s6 + s83 :|: s83 >= 0, s83 <= 0, s6 >= 0, s6 <= 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 3 + s59 + 3*z01 + 2*z01*z11 + z01^2 + 3*z11 + z11^2 }-> 1 + s60 + s82 :|: s82 >= 0, s82 <= 0, s58 >= 0, s58 <= z11, s59 >= 0, s59 <= z01 + s58, s60 >= 0, s60 <= 0, z11 >= 0, z01 >= 0, z0 >= 0, z = 1 + z0 + (1 + z01 + z11)
   plus(z, z') -{ 0 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 0 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   plus(z, z') -{ 0 }-> 1 + (1 + s24) :|: s24 >= 0, s24 <= z - 1 + (z' - 1), z' - 1 >= 0, z - 1 >= 0
   prod(z) -{ 0 }-> s56 :|: s56 >= 0, s56 <= 8 * (z - 1) + 2 * (1 + 0) + 3 * ((z - 1) * (z - 1)) + 3 * ((1 + 0) * (z - 1)) + 7, z - 1 >= 0
   prod(z) -{ 0 }-> s57 :|: s57 >= 0, s57 <= 8 * z0 + 2 * 0 + 3 * (z0 * z0) + 3 * (0 * z0) + 7, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   prod(z) -{ 0 }-> s68 :|: s66 >= 0, s66 <= inf', s67 >= 0, s67 <= 8 * z08 + 2 * s66 + 3 * (z08 * z08) + 3 * (s66 * z08) + 7, s68 >= 0, s68 <= 8 * z0 + 2 * s67 + 3 * (z0 * z0) + 3 * (s67 * z0) + 7, z08 >= 0, z18 >= 0, z0 >= 0, z = 1 + z0 + (1 + z08 + z18)
   prod(z) -{ 0 }-> 0 :|: z >= 0
   prod(z) -{ 0 }-> 1 + 0 :|: z = 0
   sum(z) -{ 0 }-> s36 :|: s36 >= 0, s36 <= z - 1 + 0, z - 1 >= 0
   sum(z) -{ 0 }-> s37 :|: s37 >= 0, s37 <= z0 + 0, z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   sum(z) -{ 0 }-> s63 :|: s61 >= 0, s61 <= z17, s62 >= 0, s62 <= z07 + s61, s63 >= 0, s63 <= z0 + s62, z = 1 + z0 + (1 + z07 + z17), z07 >= 0, z17 >= 0, z0 >= 0
   sum(z) -{ 0 }-> 0 :|: z = 0
   sum(z) -{ 0 }-> 0 :|: z >= 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 0 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   times(z, z') -{ 0 }-> 1 + s25 :|: s25 >= 0, s25 <= 0 + (z - 1), z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s26 :|: s26 >= 0, s26 <= 0 + 0, z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 0 }-> 1 + s27 :|: s27 >= 0, s27 <= 0 + 0, z' = 1 + 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s28 :|: s28 >= 0, s28 <= 0 + (z' - 1), z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s29 :|: s29 >= 0, s29 <= 0 + 0, z' - 1 >= 0, z = 1 + 0
   times(z, z') -{ 0 }-> 1 + s34 :|: s33 >= 0, s33 <= z - 2 + (z' - 2), s34 >= 0, s34 <= 0 + (1 + (1 + s33)), z - 2 >= 0, z' - 2 >= 0
   times(z, z') -{ 0 }-> 1 + s35 :|: s35 >= 0, s35 <= 0 + 0, z' - 1 >= 0, z - 1 >= 0
   times(z, z') -{ 0 }-> 1 + s52 :|: s50 >= 0, s50 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s51 >= 0, s51 <= s50 + s30, s52 >= 0, s52 <= 1 + s51 + (1 + (1 + s31)), s30 >= 0, s30 <= z - 2 + (z' - 2), s31 >= 0, s31 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0
   times(z, z') -{ 0 }-> 1 + s55 :|: s53 >= 0, s53 <= 8 * (z - 2) + 2 * (z' - 2) + 3 * ((z - 2) * (z - 2)) + 3 * ((z' - 2) * (z - 2)) + 7, s54 >= 0, s54 <= s53 + s32, s55 >= 0, s55 <= 1 + s54 + 0, s32 >= 0, s32 <= z - 2 + (z' - 2), z' - 2 >= 0, z - 2 >= 0

Function symbols to be analyzed: {PROD}
Previous analysis results are:
  +': runtime: O(n^1) [z'], size: O(1) [0]
  plus: runtime: O(1) [0], size: O(n^1) [z + z']
  times: runtime: O(1) [0], size: O(n^2) [7 + 8*z + 3*z*z' + 3*z^2 + 2*z']
  sum: runtime: O(1) [0], size: O(n^1) [z]
  prod: runtime: O(1) [0], size: INF
  *': runtime: O(n^2) [2 + 3*z + 2*z*z' + z^2 + 3*z' + z'^2], size: O(n^1) [z']
  SUM: runtime: O(n^2) [z + z^2], size: O(1) [0]
  PROD: runtime: INF, size: O(1) [0]

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

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

   plus(v0, v1) -> null_plus [0]
   times(v0, v1) -> null_times [0]
   sum(v0) -> null_sum [0]
   prod(v0) -> null_prod [0]
   +'(v0, v1) -> null_+' [0]
   *'(v0, v1) -> null_*' [0]
   SUM(v0) -> null_SUM [0]
   PROD(v0) -> null_PROD [0]

And the following fresh constants:    null_plus, null_times, null_sum, null_prod, null_+', null_*', null_SUM, null_PROD

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

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

   +'(s(z0), s(z1)) -> c2(+'(z0, z1)) [1]
   *'(s(z0), s(z1)) -> c5(+'(times(z0, z1), plus(z0, z1)), *'(z0, z1)) [1]
   SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1)) [1]
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1)) [1]
   *'(s(z0), s(z1)) -> c(+'(times(z0, z1), plus(z0, z1))) [1]
   *'(s(z0), s(z1)) -> c(+'(z0, z1)) [1]
   plus(z0, 0) -> z0 [0]
   plus(0, z0) -> z0 [0]
   plus(s(z0), s(z1)) -> s(s(plus(z0, z1))) [0]
   times(z0, 0) -> 0 [0]
   times(0, z0) -> 0 [0]
   times(s(z0), s(z1)) -> s(plus(times(z0, z1), plus(z0, z1))) [0]
   sum(nil) -> 0 [0]
   sum(cons(z0, z1)) -> plus(z0, sum(z1)) [0]
   prod(nil) -> s(0) [0]
   prod(cons(z0, z1)) -> times(z0, prod(z1)) [0]
   plus(v0, v1) -> null_plus [0]
   times(v0, v1) -> null_times [0]
   sum(v0) -> null_sum [0]
   prod(v0) -> null_prod [0]
   +'(v0, v1) -> null_+' [0]
   *'(v0, v1) -> null_*' [0]
   SUM(v0) -> null_SUM [0]
   PROD(v0) -> null_PROD [0]

The TRS has the following type information:
+' :: s:0:null_plus:null_times:null_sum:null_prod -> s:0:null_plus:null_times:null_sum:null_prod -> c2:null_+'
s :: s:0:null_plus:null_times:null_sum:null_prod -> s:0:null_plus:null_times:null_sum:null_prod
c2 :: c2:null_+' -> c2:null_+'
*' :: s:0:null_plus:null_times:null_sum:null_prod -> s:0:null_plus:null_times:null_sum:null_prod -> c5:c:null_*'
c5 :: c2:null_+' -> c5:c:null_*' -> c5:c:null_*'
times :: s:0:null_plus:null_times:null_sum:null_prod -> s:0:null_plus:null_times:null_sum:null_prod -> s:0:null_plus:null_times:null_sum:null_prod
plus :: s:0:null_plus:null_times:null_sum:null_prod -> s:0:null_plus:null_times:null_sum:null_prod -> s:0:null_plus:null_times:null_sum:null_prod
SUM :: cons:nil -> c8:null_SUM
cons :: s:0:null_plus:null_times:null_sum:null_prod -> cons:nil -> cons:nil
c8 :: c2:null_+' -> c8:null_SUM -> c8:null_SUM
sum :: cons:nil -> s:0:null_plus:null_times:null_sum:null_prod
PROD :: cons:nil -> c10:null_PROD
c10 :: c5:c:null_*' -> c10:null_PROD -> c10:null_PROD
prod :: cons:nil -> s:0:null_plus:null_times:null_sum:null_prod
c :: c2:null_+' -> c5:c:null_*'
0 :: s:0:null_plus:null_times:null_sum:null_prod
nil :: cons:nil
null_plus :: s:0:null_plus:null_times:null_sum:null_prod
null_times :: s:0:null_plus:null_times:null_sum:null_prod
null_sum :: s:0:null_plus:null_times:null_sum:null_prod
null_prod :: s:0:null_plus:null_times:null_sum:null_prod
null_+' :: c2:null_+'
null_*' :: c5:c:null_*'
null_SUM :: c8:null_SUM
null_PROD :: c10:null_PROD

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

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

   0 => 0
   nil => 0
   null_plus => 0
   null_times => 0
   null_sum => 0
   null_prod => 0
   null_+' => 0
   null_*' => 0
   null_SUM => 0
   null_PROD => 0

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

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

   *'(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   *'(z, z') -{ 1 }-> 1 + +'(z0, z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   *'(z, z') -{ 1 }-> 1 + +'(times(z0, z1), plus(z0, z1)) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   *'(z, z') -{ 1 }-> 1 + +'(times(z0, z1), plus(z0, z1)) + *'(z0, z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   +'(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   +'(z, z') -{ 1 }-> 1 + +'(z0, z1) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   PROD(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   PROD(z) -{ 1 }-> 1 + *'(z0, prod(z1)) + PROD(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   SUM(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   SUM(z) -{ 1 }-> 1 + +'(z0, sum(z1)) + SUM(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   plus(z, z') -{ 0 }-> z0 :|: z = z0, z0 >= 0, z' = 0
   plus(z, z') -{ 0 }-> z0 :|: z0 >= 0, z = 0, z' = z0
   plus(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   plus(z, z') -{ 0 }-> 1 + (1 + plus(z0, z1)) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1
   prod(z) -{ 0 }-> times(z0, prod(z1)) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   prod(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   prod(z) -{ 0 }-> 1 + 0 :|: z = 0
   sum(z) -{ 0 }-> plus(z0, sum(z1)) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   sum(z) -{ 0 }-> 0 :|: z = 0
   sum(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   times(z, z') -{ 0 }-> 0 :|: z = z0, z0 >= 0, z' = 0
   times(z, z') -{ 0 }-> 0 :|: z0 >= 0, z = 0, z' = z0
   times(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   times(z, z') -{ 0 }-> 1 + plus(times(z0, z1), plus(z0, z1)) :|: z1 >= 0, z = 1 + z0, z0 >= 0, z' = 1 + z1

Only complete derivations are relevant for the runtime complexity.

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

(101) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1))
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
We considered the (Usable) Rules:none
And the Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c5(+'(*(z0, z1), +(z0, z1)), *'(z0, z1))
   SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1))
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
   *'(s(z0), s(z1)) -> c(+'(*(z0, z1), +(z0, z1)))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(*(x_1, x_2)) = 0
   POL(*'(x_1, x_2)) = 0
   POL(+(x_1, x_2)) = [2]
   POL(+'(x_1, x_2)) = 0
   POL(0) = [2]
   POL(PROD(x_1)) = [2]x_1
   POL(SUM(x_1)) = [2]x_1
   POL(c(x_1)) = x_1
   POL(c10(x_1, x_2)) = x_1 + x_2
   POL(c2(x_1)) = x_1
   POL(c5(x_1, x_2)) = x_1 + x_2
   POL(c8(x_1, x_2)) = x_1 + x_2
   POL(cons(x_1, x_2)) = [3] + x_2
   POL(nil) = [3]
   POL(prod(x_1)) = [3] + [3]x_1
   POL(s(x_1)) = 0
   POL(sum(x_1)) = [2] + [2]x_1

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

(102)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c5(+'(*(z0, z1), +(z0, z1)), *'(z0, z1))
   SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1))
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
   *'(s(z0), s(z1)) -> c(+'(*(z0, z1), +(z0, z1)))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
S tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c5(+'(*(z0, z1), +(z0, z1)), *'(z0, z1))
   *'(s(z0), s(z1)) -> c(+'(*(z0, z1), +(z0, z1)))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
K tuples:
   SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1))
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, *'_2, SUM_1, PROD_1

Compound Symbols:   c2_1, c5_2, c8_2, c10_2, c_1


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

(103) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   *'(s(z0), s(z1)) -> c5(+'(*(z0, z1), +(z0, z1)), *'(z0, z1))
   *'(s(z0), s(z1)) -> c(+'(*(z0, z1), +(z0, z1)))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
We considered the (Usable) Rules:none
And the Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c5(+'(*(z0, z1), +(z0, z1)), *'(z0, z1))
   SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1))
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
   *'(s(z0), s(z1)) -> c(+'(*(z0, z1), +(z0, z1)))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(*(x_1, x_2)) = [1] + x_1 + x_2
   POL(*'(x_1, x_2)) = x_1
   POL(+(x_1, x_2)) = x_1 + x_2
   POL(+'(x_1, x_2)) = 0
   POL(0) = [1]
   POL(PROD(x_1)) = x_1
   POL(SUM(x_1)) = x_1
   POL(c(x_1)) = x_1
   POL(c10(x_1, x_2)) = x_1 + x_2
   POL(c2(x_1)) = x_1
   POL(c5(x_1, x_2)) = x_1 + x_2
   POL(c8(x_1, x_2)) = x_1 + x_2
   POL(cons(x_1, x_2)) = [1] + x_1 + x_2
   POL(nil) = [1]
   POL(prod(x_1)) = [1] + x_1
   POL(s(x_1)) = [1] + x_1
   POL(sum(x_1)) = [1] + x_1

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

(104)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c5(+'(*(z0, z1), +(z0, z1)), *'(z0, z1))
   SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1))
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
   *'(s(z0), s(z1)) -> c(+'(*(z0, z1), +(z0, z1)))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
S tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
K tuples:
   SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1))
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
   *'(s(z0), s(z1)) -> c5(+'(*(z0, z1), +(z0, z1)), *'(z0, z1))
   *'(s(z0), s(z1)) -> c(+'(*(z0, z1), +(z0, z1)))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, *'_2, SUM_1, PROD_1

Compound Symbols:   c2_1, c5_2, c8_2, c10_2, c_1


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

(105) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace *'(s(z0), s(z1)) -> c5(+'(*(z0, z1), +(z0, z1)), *'(z0, z1)) by 
   *'(s(z0), s(0)) -> c5(+'(*(z0, 0), z0), *'(z0, 0))
   *'(s(0), s(z0)) -> c5(+'(*(0, z0), z0), *'(0, z0))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(*(s(z0), s(z1)), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(z0), s(0)) -> c5(+'(0, +(z0, 0)), *'(z0, 0))
   *'(s(0), s(z0)) -> c5(+'(0, +(0, z0)), *'(0, z0))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))), *'(s(z0), s(z1)))

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

(106)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1))
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
   *'(s(z0), s(z1)) -> c(+'(*(z0, z1), +(z0, z1)))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
   *'(s(z0), s(0)) -> c5(+'(*(z0, 0), z0), *'(z0, 0))
   *'(s(0), s(z0)) -> c5(+'(*(0, z0), z0), *'(0, z0))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(*(s(z0), s(z1)), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(z0), s(0)) -> c5(+'(0, +(z0, 0)), *'(z0, 0))
   *'(s(0), s(z0)) -> c5(+'(0, +(0, z0)), *'(0, z0))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))), *'(s(z0), s(z1)))
S tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
K tuples:
   SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1))
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
   *'(s(z0), s(z1)) -> c5(+'(*(z0, z1), +(z0, z1)), *'(z0, z1))
   *'(s(z0), s(z1)) -> c(+'(*(z0, z1), +(z0, z1)))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, SUM_1, PROD_1, *'_2

Compound Symbols:   c2_1, c8_2, c10_2, c_1, c5_2


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

(107) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 2 trailing nodes:
   *'(s(z0), s(0)) -> c5(+'(0, +(z0, 0)), *'(z0, 0))
   *'(s(0), s(z0)) -> c5(+'(0, +(0, z0)), *'(0, z0))

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

(108)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1))
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
   *'(s(z0), s(z1)) -> c(+'(*(z0, z1), +(z0, z1)))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
   *'(s(z0), s(0)) -> c5(+'(*(z0, 0), z0), *'(z0, 0))
   *'(s(0), s(z0)) -> c5(+'(*(0, z0), z0), *'(0, z0))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(*(s(z0), s(z1)), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))), *'(s(z0), s(z1)))
S tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
K tuples:
   SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1))
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
   *'(s(z0), s(z1)) -> c(+'(*(z0, z1), +(z0, z1)))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, SUM_1, PROD_1, *'_2

Compound Symbols:   c2_1, c8_2, c10_2, c_1, c5_2


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

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

(110)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1))
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
   *'(s(z0), s(z1)) -> c(+'(*(z0, z1), +(z0, z1)))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(*(s(z0), s(z1)), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))), *'(s(z0), s(z1)))
   *'(s(z0), s(0)) -> c5(+'(*(z0, 0), z0))
   *'(s(0), s(z0)) -> c5(+'(*(0, z0), z0))
S tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
K tuples:
   SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1))
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
   *'(s(z0), s(z1)) -> c(+'(*(z0, z1), +(z0, z1)))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, SUM_1, PROD_1, *'_2

Compound Symbols:   c2_1, c8_2, c10_2, c_1, c5_2, c5_1


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

(111) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1)) by 
   SUM(cons(x0, nil)) -> c8(+'(x0, 0), SUM(nil))
   SUM(cons(x0, cons(z0, z1))) -> c8(+'(x0, +(z0, sum(z1))), SUM(cons(z0, z1)))

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

(112)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
   *'(s(z0), s(z1)) -> c(+'(*(z0, z1), +(z0, z1)))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(*(s(z0), s(z1)), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))), *'(s(z0), s(z1)))
   *'(s(z0), s(0)) -> c5(+'(*(z0, 0), z0))
   *'(s(0), s(z0)) -> c5(+'(*(0, z0), z0))
   SUM(cons(x0, nil)) -> c8(+'(x0, 0), SUM(nil))
   SUM(cons(x0, cons(z0, z1))) -> c8(+'(x0, +(z0, sum(z1))), SUM(cons(z0, z1)))
S tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
K tuples:
   SUM(cons(z0, z1)) -> c8(+'(z0, sum(z1)), SUM(z1))
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
   *'(s(z0), s(z1)) -> c(+'(*(z0, z1), +(z0, z1)))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, PROD_1, *'_2, SUM_1

Compound Symbols:   c2_1, c10_2, c_1, c5_2, c5_1, c8_2


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

(113) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   SUM(cons(x0, nil)) -> c8(+'(x0, 0), SUM(nil))

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

(114)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
   *'(s(z0), s(z1)) -> c(+'(*(z0, z1), +(z0, z1)))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(*(s(z0), s(z1)), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))), *'(s(z0), s(z1)))
   *'(s(z0), s(0)) -> c5(+'(*(z0, 0), z0))
   *'(s(0), s(z0)) -> c5(+'(*(0, z0), z0))
   SUM(cons(x0, cons(z0, z1))) -> c8(+'(x0, +(z0, sum(z1))), SUM(cons(z0, z1)))
S tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
K tuples:
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
   *'(s(z0), s(z1)) -> c(+'(*(z0, z1), +(z0, z1)))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, PROD_1, *'_2, SUM_1

Compound Symbols:   c2_1, c10_2, c_1, c5_2, c5_1, c8_2


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

(115) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1)) by 
   PROD(cons(x0, nil)) -> c10(*'(x0, s(0)), PROD(nil))
   PROD(cons(x0, cons(z0, z1))) -> c10(*'(x0, *(z0, prod(z1))), PROD(cons(z0, z1)))

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

(116)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c(+'(*(z0, z1), +(z0, z1)))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(*(s(z0), s(z1)), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))), *'(s(z0), s(z1)))
   *'(s(z0), s(0)) -> c5(+'(*(z0, 0), z0))
   *'(s(0), s(z0)) -> c5(+'(*(0, z0), z0))
   SUM(cons(x0, cons(z0, z1))) -> c8(+'(x0, +(z0, sum(z1))), SUM(cons(z0, z1)))
   PROD(cons(x0, nil)) -> c10(*'(x0, s(0)), PROD(nil))
   PROD(cons(x0, cons(z0, z1))) -> c10(*'(x0, *(z0, prod(z1))), PROD(cons(z0, z1)))
S tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
K tuples:
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
   *'(s(z0), s(z1)) -> c(+'(*(z0, z1), +(z0, z1)))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, *'_2, SUM_1, PROD_1

Compound Symbols:   c2_1, c_1, c5_2, c5_1, c8_2, c10_2


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

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

(118)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c(+'(*(z0, z1), +(z0, z1)))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(*(s(z0), s(z1)), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))), *'(s(z0), s(z1)))
   *'(s(z0), s(0)) -> c5(+'(*(z0, 0), z0))
   *'(s(0), s(z0)) -> c5(+'(*(0, z0), z0))
   SUM(cons(x0, cons(z0, z1))) -> c8(+'(x0, +(z0, sum(z1))), SUM(cons(z0, z1)))
   PROD(cons(x0, cons(z0, z1))) -> c10(*'(x0, *(z0, prod(z1))), PROD(cons(z0, z1)))
   PROD(cons(x0, nil)) -> c10(*'(x0, s(0)))
S tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
K tuples:
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
   *'(s(z0), s(z1)) -> c(+'(*(z0, z1), +(z0, z1)))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, *'_2, SUM_1, PROD_1

Compound Symbols:   c2_1, c_1, c5_2, c5_1, c8_2, c10_2, c10_1


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

(119) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace *'(s(z0), s(z1)) -> c(+'(*(z0, z1), +(z0, z1))) by 
   *'(s(z0), s(0)) -> c(+'(*(z0, 0), z0))
   *'(s(0), s(z0)) -> c(+'(*(0, z0), z0))
   *'(s(s(z0)), s(s(z1))) -> c(+'(*(s(z0), s(z1)), s(s(+(z0, z1)))))
   *'(s(z0), s(0)) -> c(+'(0, +(z0, 0)))
   *'(s(0), s(z0)) -> c(+'(0, +(0, z0)))
   *'(s(s(z0)), s(s(z1))) -> c(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))))

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

(120)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(*(s(z0), s(z1)), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))), *'(s(z0), s(z1)))
   *'(s(z0), s(0)) -> c5(+'(*(z0, 0), z0))
   *'(s(0), s(z0)) -> c5(+'(*(0, z0), z0))
   SUM(cons(x0, cons(z0, z1))) -> c8(+'(x0, +(z0, sum(z1))), SUM(cons(z0, z1)))
   PROD(cons(x0, cons(z0, z1))) -> c10(*'(x0, *(z0, prod(z1))), PROD(cons(z0, z1)))
   PROD(cons(x0, nil)) -> c10(*'(x0, s(0)))
   *'(s(z0), s(0)) -> c(+'(*(z0, 0), z0))
   *'(s(0), s(z0)) -> c(+'(*(0, z0), z0))
   *'(s(s(z0)), s(s(z1))) -> c(+'(*(s(z0), s(z1)), s(s(+(z0, z1)))))
   *'(s(z0), s(0)) -> c(+'(0, +(z0, 0)))
   *'(s(0), s(z0)) -> c(+'(0, +(0, z0)))
   *'(s(s(z0)), s(s(z1))) -> c(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))))
S tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
K tuples:
   PROD(cons(z0, z1)) -> c10(*'(z0, prod(z1)), PROD(z1))
   *'(s(z0), s(z1)) -> c(+'(*(z0, z1), +(z0, z1)))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, *'_2, SUM_1, PROD_1

Compound Symbols:   c2_1, c_1, c5_2, c5_1, c8_2, c10_2, c10_1


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

(121) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 2 trailing nodes:
   *'(s(z0), s(0)) -> c(+'(0, +(z0, 0)))
   *'(s(0), s(z0)) -> c(+'(0, +(0, z0)))

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

(122)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(*(s(z0), s(z1)), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))), *'(s(z0), s(z1)))
   *'(s(z0), s(0)) -> c5(+'(*(z0, 0), z0))
   *'(s(0), s(z0)) -> c5(+'(*(0, z0), z0))
   SUM(cons(x0, cons(z0, z1))) -> c8(+'(x0, +(z0, sum(z1))), SUM(cons(z0, z1)))
   PROD(cons(x0, cons(z0, z1))) -> c10(*'(x0, *(z0, prod(z1))), PROD(cons(z0, z1)))
   PROD(cons(x0, nil)) -> c10(*'(x0, s(0)))
   *'(s(z0), s(0)) -> c(+'(*(z0, 0), z0))
   *'(s(0), s(z0)) -> c(+'(*(0, z0), z0))
   *'(s(s(z0)), s(s(z1))) -> c(+'(*(s(z0), s(z1)), s(s(+(z0, z1)))))
   *'(s(s(z0)), s(s(z1))) -> c(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))))
S tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
K tuples:
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, *'_2, SUM_1, PROD_1

Compound Symbols:   c2_1, c_1, c5_2, c5_1, c8_2, c10_2, c10_1


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

(123) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace *'(s(s(z0)), s(s(z1))) -> c5(+'(*(s(z0), s(z1)), s(s(+(z0, z1)))), *'(s(z0), s(z1))) by 
   *'(s(s(z0)), s(s(0))) -> c5(+'(*(s(z0), s(0)), s(s(z0))), *'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c5(+'(*(s(0), s(z0)), s(s(z0))), *'(s(0), s(z0)))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))), *'(s(z0), s(z1)))

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

(124)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))), *'(s(z0), s(z1)))
   *'(s(z0), s(0)) -> c5(+'(*(z0, 0), z0))
   *'(s(0), s(z0)) -> c5(+'(*(0, z0), z0))
   SUM(cons(x0, cons(z0, z1))) -> c8(+'(x0, +(z0, sum(z1))), SUM(cons(z0, z1)))
   PROD(cons(x0, cons(z0, z1))) -> c10(*'(x0, *(z0, prod(z1))), PROD(cons(z0, z1)))
   PROD(cons(x0, nil)) -> c10(*'(x0, s(0)))
   *'(s(z0), s(0)) -> c(+'(*(z0, 0), z0))
   *'(s(0), s(z0)) -> c(+'(*(0, z0), z0))
   *'(s(s(z0)), s(s(z1))) -> c(+'(*(s(z0), s(z1)), s(s(+(z0, z1)))))
   *'(s(s(z0)), s(s(z1))) -> c(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))))
   *'(s(s(z0)), s(s(0))) -> c5(+'(*(s(z0), s(0)), s(s(z0))), *'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c5(+'(*(s(0), s(z0)), s(s(z0))), *'(s(0), s(z0)))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
S tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
K tuples:
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, *'_2, SUM_1, PROD_1

Compound Symbols:   c2_1, c_1, c5_2, c5_1, c8_2, c10_2, c10_1


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

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

(126)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))), *'(s(z0), s(z1)))
   *'(s(z0), s(0)) -> c5(+'(*(z0, 0), z0))
   *'(s(0), s(z0)) -> c5(+'(*(0, z0), z0))
   SUM(cons(x0, cons(z0, z1))) -> c8(+'(x0, +(z0, sum(z1))), SUM(cons(z0, z1)))
   PROD(cons(x0, cons(z0, z1))) -> c10(*'(x0, *(z0, prod(z1))), PROD(cons(z0, z1)))
   PROD(cons(x0, nil)) -> c10(*'(x0, s(0)))
   *'(s(z0), s(0)) -> c(+'(*(z0, 0), z0))
   *'(s(0), s(z0)) -> c(+'(*(0, z0), z0))
   *'(s(s(z0)), s(s(z1))) -> c(+'(*(s(z0), s(z1)), s(s(+(z0, z1)))))
   *'(s(s(z0)), s(s(z1))) -> c(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(0))) -> c1(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(z0)), s(s(0))) -> c1(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c1(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c1(*'(s(0), s(z0)))
S tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
K tuples:
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, *'_2, SUM_1, PROD_1

Compound Symbols:   c2_1, c_1, c5_2, c5_1, c8_2, c10_2, c10_1, c1_1


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

(127) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))), *'(s(z0), s(z1))) by 
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(0))) -> c5(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))), *'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c5(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))), *'(s(0), s(z0)))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(0))) -> c5(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))), *'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c5(+'(s(+(0, +(0, z0))), +(s(0), s(z0))), *'(s(0), s(z0)))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))

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

(128)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
   *'(s(z0), s(0)) -> c5(+'(*(z0, 0), z0))
   *'(s(0), s(z0)) -> c5(+'(*(0, z0), z0))
   SUM(cons(x0, cons(z0, z1))) -> c8(+'(x0, +(z0, sum(z1))), SUM(cons(z0, z1)))
   PROD(cons(x0, cons(z0, z1))) -> c10(*'(x0, *(z0, prod(z1))), PROD(cons(z0, z1)))
   PROD(cons(x0, nil)) -> c10(*'(x0, s(0)))
   *'(s(z0), s(0)) -> c(+'(*(z0, 0), z0))
   *'(s(0), s(z0)) -> c(+'(*(0, z0), z0))
   *'(s(s(z0)), s(s(z1))) -> c(+'(*(s(z0), s(z1)), s(s(+(z0, z1)))))
   *'(s(s(z0)), s(s(z1))) -> c(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(0))) -> c1(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(z0)), s(s(0))) -> c1(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c1(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c1(*'(s(0), s(z0)))
   *'(s(s(z0)), s(s(0))) -> c5(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))), *'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c5(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))), *'(s(0), s(z0)))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(0))) -> c5(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))), *'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c5(+'(s(+(0, +(0, z0))), +(s(0), s(z0))), *'(s(0), s(z0)))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
S tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
K tuples:
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, *'_2, SUM_1, PROD_1

Compound Symbols:   c2_1, c_1, c5_1, c8_2, c10_2, c10_1, c5_2, c1_1


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

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

(130)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
   *'(s(z0), s(0)) -> c5(+'(*(z0, 0), z0))
   *'(s(0), s(z0)) -> c5(+'(*(0, z0), z0))
   SUM(cons(x0, cons(z0, z1))) -> c8(+'(x0, +(z0, sum(z1))), SUM(cons(z0, z1)))
   PROD(cons(x0, cons(z0, z1))) -> c10(*'(x0, *(z0, prod(z1))), PROD(cons(z0, z1)))
   PROD(cons(x0, nil)) -> c10(*'(x0, s(0)))
   *'(s(z0), s(0)) -> c(+'(*(z0, 0), z0))
   *'(s(0), s(z0)) -> c(+'(*(0, z0), z0))
   *'(s(s(z0)), s(s(z1))) -> c(+'(*(s(z0), s(z1)), s(s(+(z0, z1)))))
   *'(s(s(z0)), s(s(z1))) -> c(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(0))) -> c1(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(z0)), s(s(0))) -> c1(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c1(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c1(*'(s(0), s(z0)))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))))
   *'(s(s(z0)), s(s(0))) -> c3(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))))
   *'(s(s(0)), s(s(z0))) -> c3(*'(s(0), s(z0)))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(0, +(0, z0))), +(s(0), s(z0))))
S tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
K tuples:
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, *'_2, SUM_1, PROD_1

Compound Symbols:   c2_1, c_1, c5_1, c8_2, c10_2, c10_1, c5_2, c1_1, c3_1


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

(131) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace *'(s(z0), s(0)) -> c5(+'(*(z0, 0), z0)) by 
   *'(s(z0), s(0)) -> c5(+'(0, z0))
   *'(s(0), s(0)) -> c5(+'(0, 0))

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

(132)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
   *'(s(0), s(z0)) -> c5(+'(*(0, z0), z0))
   SUM(cons(x0, cons(z0, z1))) -> c8(+'(x0, +(z0, sum(z1))), SUM(cons(z0, z1)))
   PROD(cons(x0, cons(z0, z1))) -> c10(*'(x0, *(z0, prod(z1))), PROD(cons(z0, z1)))
   PROD(cons(x0, nil)) -> c10(*'(x0, s(0)))
   *'(s(z0), s(0)) -> c(+'(*(z0, 0), z0))
   *'(s(0), s(z0)) -> c(+'(*(0, z0), z0))
   *'(s(s(z0)), s(s(z1))) -> c(+'(*(s(z0), s(z1)), s(s(+(z0, z1)))))
   *'(s(s(z0)), s(s(z1))) -> c(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(0))) -> c1(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(z0)), s(s(0))) -> c1(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c1(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c1(*'(s(0), s(z0)))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))))
   *'(s(s(z0)), s(s(0))) -> c3(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))))
   *'(s(s(0)), s(s(z0))) -> c3(*'(s(0), s(z0)))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(0, +(0, z0))), +(s(0), s(z0))))
   *'(s(z0), s(0)) -> c5(+'(0, z0))
   *'(s(0), s(0)) -> c5(+'(0, 0))
S tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
K tuples:
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, *'_2, SUM_1, PROD_1

Compound Symbols:   c2_1, c_1, c5_1, c8_2, c10_2, c10_1, c5_2, c1_1, c3_1


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

(133) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 2 trailing nodes:
   *'(s(z0), s(0)) -> c5(+'(0, z0))
   *'(s(0), s(0)) -> c5(+'(0, 0))

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

(134)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
   *'(s(0), s(z0)) -> c5(+'(*(0, z0), z0))
   SUM(cons(x0, cons(z0, z1))) -> c8(+'(x0, +(z0, sum(z1))), SUM(cons(z0, z1)))
   PROD(cons(x0, cons(z0, z1))) -> c10(*'(x0, *(z0, prod(z1))), PROD(cons(z0, z1)))
   PROD(cons(x0, nil)) -> c10(*'(x0, s(0)))
   *'(s(z0), s(0)) -> c(+'(*(z0, 0), z0))
   *'(s(0), s(z0)) -> c(+'(*(0, z0), z0))
   *'(s(s(z0)), s(s(z1))) -> c(+'(*(s(z0), s(z1)), s(s(+(z0, z1)))))
   *'(s(s(z0)), s(s(z1))) -> c(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(0))) -> c1(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(z0)), s(s(0))) -> c1(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c1(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c1(*'(s(0), s(z0)))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))))
   *'(s(s(z0)), s(s(0))) -> c3(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))))
   *'(s(s(0)), s(s(z0))) -> c3(*'(s(0), s(z0)))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(0, +(0, z0))), +(s(0), s(z0))))
S tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
K tuples:
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, *'_2, SUM_1, PROD_1

Compound Symbols:   c2_1, c_1, c5_1, c8_2, c10_2, c10_1, c5_2, c1_1, c3_1


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

(135) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace *'(s(0), s(z0)) -> c5(+'(*(0, z0), z0)) by 
   *'(s(0), s(0)) -> c5(+'(0, 0))
   *'(s(0), s(z0)) -> c5(+'(0, z0))

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

(136)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
   SUM(cons(x0, cons(z0, z1))) -> c8(+'(x0, +(z0, sum(z1))), SUM(cons(z0, z1)))
   PROD(cons(x0, cons(z0, z1))) -> c10(*'(x0, *(z0, prod(z1))), PROD(cons(z0, z1)))
   PROD(cons(x0, nil)) -> c10(*'(x0, s(0)))
   *'(s(z0), s(0)) -> c(+'(*(z0, 0), z0))
   *'(s(0), s(z0)) -> c(+'(*(0, z0), z0))
   *'(s(s(z0)), s(s(z1))) -> c(+'(*(s(z0), s(z1)), s(s(+(z0, z1)))))
   *'(s(s(z0)), s(s(z1))) -> c(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(0))) -> c1(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(z0)), s(s(0))) -> c1(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c1(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c1(*'(s(0), s(z0)))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))))
   *'(s(s(z0)), s(s(0))) -> c3(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))))
   *'(s(s(0)), s(s(z0))) -> c3(*'(s(0), s(z0)))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(0, +(0, z0))), +(s(0), s(z0))))
   *'(s(0), s(0)) -> c5(+'(0, 0))
   *'(s(0), s(z0)) -> c5(+'(0, z0))
S tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
K tuples:
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, *'_2, SUM_1, PROD_1

Compound Symbols:   c2_1, c_1, c8_2, c10_2, c10_1, c5_2, c1_1, c3_1, c5_1


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

(137) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 2 trailing nodes:
   *'(s(0), s(0)) -> c5(+'(0, 0))
   *'(s(0), s(z0)) -> c5(+'(0, z0))

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

(138)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
   SUM(cons(x0, cons(z0, z1))) -> c8(+'(x0, +(z0, sum(z1))), SUM(cons(z0, z1)))
   PROD(cons(x0, cons(z0, z1))) -> c10(*'(x0, *(z0, prod(z1))), PROD(cons(z0, z1)))
   PROD(cons(x0, nil)) -> c10(*'(x0, s(0)))
   *'(s(z0), s(0)) -> c(+'(*(z0, 0), z0))
   *'(s(0), s(z0)) -> c(+'(*(0, z0), z0))
   *'(s(s(z0)), s(s(z1))) -> c(+'(*(s(z0), s(z1)), s(s(+(z0, z1)))))
   *'(s(s(z0)), s(s(z1))) -> c(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(0))) -> c1(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(z0)), s(s(0))) -> c1(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c1(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c1(*'(s(0), s(z0)))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))))
   *'(s(s(z0)), s(s(0))) -> c3(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))))
   *'(s(s(0)), s(s(z0))) -> c3(*'(s(0), s(z0)))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(0, +(0, z0))), +(s(0), s(z0))))
S tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
K tuples:
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, *'_2, SUM_1, PROD_1

Compound Symbols:   c2_1, c_1, c8_2, c10_2, c10_1, c5_2, c1_1, c3_1


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

(139) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace SUM(cons(x0, cons(z0, z1))) -> c8(+'(x0, +(z0, sum(z1))), SUM(cons(z0, z1))) by 
   SUM(cons(x0, cons(0, x2))) -> c8(+'(x0, sum(x2)), SUM(cons(0, x2)))
   SUM(cons(x0, cons(x1, nil))) -> c8(+'(x0, +(x1, 0)), SUM(cons(x1, nil)))
   SUM(cons(x0, cons(x1, cons(z0, z1)))) -> c8(+'(x0, +(x1, +(z0, sum(z1)))), SUM(cons(x1, cons(z0, z1))))

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

(140)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
   PROD(cons(x0, cons(z0, z1))) -> c10(*'(x0, *(z0, prod(z1))), PROD(cons(z0, z1)))
   PROD(cons(x0, nil)) -> c10(*'(x0, s(0)))
   *'(s(z0), s(0)) -> c(+'(*(z0, 0), z0))
   *'(s(0), s(z0)) -> c(+'(*(0, z0), z0))
   *'(s(s(z0)), s(s(z1))) -> c(+'(*(s(z0), s(z1)), s(s(+(z0, z1)))))
   *'(s(s(z0)), s(s(z1))) -> c(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(0))) -> c1(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(z0)), s(s(0))) -> c1(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c1(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c1(*'(s(0), s(z0)))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))))
   *'(s(s(z0)), s(s(0))) -> c3(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))))
   *'(s(s(0)), s(s(z0))) -> c3(*'(s(0), s(z0)))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(0, +(0, z0))), +(s(0), s(z0))))
   SUM(cons(x0, cons(0, x2))) -> c8(+'(x0, sum(x2)), SUM(cons(0, x2)))
   SUM(cons(x0, cons(x1, nil))) -> c8(+'(x0, +(x1, 0)), SUM(cons(x1, nil)))
   SUM(cons(x0, cons(x1, cons(z0, z1)))) -> c8(+'(x0, +(x1, +(z0, sum(z1)))), SUM(cons(x1, cons(z0, z1))))
S tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
K tuples:
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, *'_2, PROD_1, SUM_1

Compound Symbols:   c2_1, c_1, c10_2, c10_1, c5_2, c1_1, c3_1, c8_2


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

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

(142)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
   PROD(cons(x0, cons(z0, z1))) -> c10(*'(x0, *(z0, prod(z1))), PROD(cons(z0, z1)))
   PROD(cons(x0, nil)) -> c10(*'(x0, s(0)))
   *'(s(z0), s(0)) -> c(+'(*(z0, 0), z0))
   *'(s(0), s(z0)) -> c(+'(*(0, z0), z0))
   *'(s(s(z0)), s(s(z1))) -> c(+'(*(s(z0), s(z1)), s(s(+(z0, z1)))))
   *'(s(s(z0)), s(s(z1))) -> c(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(0))) -> c1(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(z0)), s(s(0))) -> c1(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c1(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c1(*'(s(0), s(z0)))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))))
   *'(s(s(z0)), s(s(0))) -> c3(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))))
   *'(s(s(0)), s(s(z0))) -> c3(*'(s(0), s(z0)))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(0, +(0, z0))), +(s(0), s(z0))))
   SUM(cons(x0, cons(0, x2))) -> c8(+'(x0, sum(x2)), SUM(cons(0, x2)))
   SUM(cons(x0, cons(x1, cons(z0, z1)))) -> c8(+'(x0, +(x1, +(z0, sum(z1)))), SUM(cons(x1, cons(z0, z1))))
   SUM(cons(x0, cons(x1, nil))) -> c8(+'(x0, +(x1, 0)))
S tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
K tuples:
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, *'_2, PROD_1, SUM_1

Compound Symbols:   c2_1, c_1, c10_2, c10_1, c5_2, c1_1, c3_1, c8_2, c8_1


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

(143) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace PROD(cons(x0, cons(z0, z1))) -> c10(*'(x0, *(z0, prod(z1))), PROD(cons(z0, z1))) by 
   PROD(cons(x0, cons(0, x2))) -> c10(*'(x0, 0), PROD(cons(0, x2)))
   PROD(cons(x0, cons(x1, nil))) -> c10(*'(x0, *(x1, s(0))), PROD(cons(x1, nil)))
   PROD(cons(x0, cons(x1, cons(z0, z1)))) -> c10(*'(x0, *(x1, *(z0, prod(z1)))), PROD(cons(x1, cons(z0, z1))))

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

(144)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
   PROD(cons(x0, nil)) -> c10(*'(x0, s(0)))
   *'(s(z0), s(0)) -> c(+'(*(z0, 0), z0))
   *'(s(0), s(z0)) -> c(+'(*(0, z0), z0))
   *'(s(s(z0)), s(s(z1))) -> c(+'(*(s(z0), s(z1)), s(s(+(z0, z1)))))
   *'(s(s(z0)), s(s(z1))) -> c(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(0))) -> c1(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(z0)), s(s(0))) -> c1(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c1(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c1(*'(s(0), s(z0)))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))))
   *'(s(s(z0)), s(s(0))) -> c3(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))))
   *'(s(s(0)), s(s(z0))) -> c3(*'(s(0), s(z0)))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(0, +(0, z0))), +(s(0), s(z0))))
   SUM(cons(x0, cons(0, x2))) -> c8(+'(x0, sum(x2)), SUM(cons(0, x2)))
   SUM(cons(x0, cons(x1, cons(z0, z1)))) -> c8(+'(x0, +(x1, +(z0, sum(z1)))), SUM(cons(x1, cons(z0, z1))))
   SUM(cons(x0, cons(x1, nil))) -> c8(+'(x0, +(x1, 0)))
   PROD(cons(x0, cons(0, x2))) -> c10(*'(x0, 0), PROD(cons(0, x2)))
   PROD(cons(x0, cons(x1, nil))) -> c10(*'(x0, *(x1, s(0))), PROD(cons(x1, nil)))
   PROD(cons(x0, cons(x1, cons(z0, z1)))) -> c10(*'(x0, *(x1, *(z0, prod(z1)))), PROD(cons(x1, cons(z0, z1))))
S tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
K tuples:
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, *'_2, PROD_1, SUM_1

Compound Symbols:   c2_1, c_1, c10_1, c5_2, c1_1, c3_1, c8_2, c8_1, c10_2


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

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

(146)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
   PROD(cons(x0, nil)) -> c10(*'(x0, s(0)))
   *'(s(z0), s(0)) -> c(+'(*(z0, 0), z0))
   *'(s(0), s(z0)) -> c(+'(*(0, z0), z0))
   *'(s(s(z0)), s(s(z1))) -> c(+'(*(s(z0), s(z1)), s(s(+(z0, z1)))))
   *'(s(s(z0)), s(s(z1))) -> c(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(0))) -> c1(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(z0)), s(s(0))) -> c1(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c1(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c1(*'(s(0), s(z0)))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))))
   *'(s(s(z0)), s(s(0))) -> c3(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))))
   *'(s(s(0)), s(s(z0))) -> c3(*'(s(0), s(z0)))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(0, +(0, z0))), +(s(0), s(z0))))
   SUM(cons(x0, cons(0, x2))) -> c8(+'(x0, sum(x2)), SUM(cons(0, x2)))
   SUM(cons(x0, cons(x1, cons(z0, z1)))) -> c8(+'(x0, +(x1, +(z0, sum(z1)))), SUM(cons(x1, cons(z0, z1))))
   SUM(cons(x0, cons(x1, nil))) -> c8(+'(x0, +(x1, 0)))
   PROD(cons(x0, cons(x1, nil))) -> c10(*'(x0, *(x1, s(0))), PROD(cons(x1, nil)))
   PROD(cons(x0, cons(x1, cons(z0, z1)))) -> c10(*'(x0, *(x1, *(z0, prod(z1)))), PROD(cons(x1, cons(z0, z1))))
   PROD(cons(x0, cons(0, x2))) -> c10(PROD(cons(0, x2)))
S tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
K tuples:
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, *'_2, PROD_1, SUM_1

Compound Symbols:   c2_1, c_1, c10_1, c5_2, c1_1, c3_1, c8_2, c8_1, c10_2


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

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

(148)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
   PROD(cons(x0, nil)) -> c10(*'(x0, s(0)))
   *'(s(z0), s(0)) -> c(+'(*(z0, 0), z0))
   *'(s(0), s(z0)) -> c(+'(*(0, z0), z0))
   *'(s(s(z0)), s(s(z1))) -> c(+'(*(s(z0), s(z1)), s(s(+(z0, z1)))))
   *'(s(s(z0)), s(s(z1))) -> c(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(0))) -> c1(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(z0)), s(s(0))) -> c1(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c1(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c1(*'(s(0), s(z0)))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))))
   *'(s(s(z0)), s(s(0))) -> c3(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))))
   *'(s(s(0)), s(s(z0))) -> c3(*'(s(0), s(z0)))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(0, +(0, z0))), +(s(0), s(z0))))
   SUM(cons(x0, cons(0, x2))) -> c8(+'(x0, sum(x2)), SUM(cons(0, x2)))
   SUM(cons(x0, cons(x1, cons(z0, z1)))) -> c8(+'(x0, +(x1, +(z0, sum(z1)))), SUM(cons(x1, cons(z0, z1))))
   SUM(cons(x0, cons(x1, nil))) -> c8(+'(x0, +(x1, 0)))
   PROD(cons(x0, cons(x1, cons(z0, z1)))) -> c10(*'(x0, *(x1, *(z0, prod(z1)))), PROD(cons(x1, cons(z0, z1))))
   PROD(cons(x0, cons(0, x2))) -> c10(PROD(cons(0, x2)))
   PROD(cons(x0, cons(x1, nil))) -> c4(*'(x0, *(x1, s(0))))
   PROD(cons(x0, cons(x1, nil))) -> c4(PROD(cons(x1, nil)))
S tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
K tuples:
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, *'_2, PROD_1, SUM_1

Compound Symbols:   c2_1, c_1, c10_1, c5_2, c1_1, c3_1, c8_2, c8_1, c10_2, c4_1


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

(149) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace *'(s(z0), s(0)) -> c(+'(*(z0, 0), z0)) by 
   *'(s(z0), s(0)) -> c(+'(0, z0))
   *'(s(0), s(0)) -> c(+'(0, 0))

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

(150)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
   PROD(cons(x0, nil)) -> c10(*'(x0, s(0)))
   *'(s(0), s(z0)) -> c(+'(*(0, z0), z0))
   *'(s(s(z0)), s(s(z1))) -> c(+'(*(s(z0), s(z1)), s(s(+(z0, z1)))))
   *'(s(s(z0)), s(s(z1))) -> c(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(0))) -> c1(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(z0)), s(s(0))) -> c1(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c1(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c1(*'(s(0), s(z0)))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))))
   *'(s(s(z0)), s(s(0))) -> c3(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))))
   *'(s(s(0)), s(s(z0))) -> c3(*'(s(0), s(z0)))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(0, +(0, z0))), +(s(0), s(z0))))
   SUM(cons(x0, cons(0, x2))) -> c8(+'(x0, sum(x2)), SUM(cons(0, x2)))
   SUM(cons(x0, cons(x1, cons(z0, z1)))) -> c8(+'(x0, +(x1, +(z0, sum(z1)))), SUM(cons(x1, cons(z0, z1))))
   SUM(cons(x0, cons(x1, nil))) -> c8(+'(x0, +(x1, 0)))
   PROD(cons(x0, cons(x1, cons(z0, z1)))) -> c10(*'(x0, *(x1, *(z0, prod(z1)))), PROD(cons(x1, cons(z0, z1))))
   PROD(cons(x0, cons(0, x2))) -> c10(PROD(cons(0, x2)))
   PROD(cons(x0, cons(x1, nil))) -> c4(*'(x0, *(x1, s(0))))
   PROD(cons(x0, cons(x1, nil))) -> c4(PROD(cons(x1, nil)))
   *'(s(z0), s(0)) -> c(+'(0, z0))
   *'(s(0), s(0)) -> c(+'(0, 0))
S tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
K tuples:
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, *'_2, PROD_1, SUM_1

Compound Symbols:   c2_1, c_1, c10_1, c5_2, c1_1, c3_1, c8_2, c8_1, c10_2, c4_1


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

(151) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 2 trailing nodes:
   *'(s(z0), s(0)) -> c(+'(0, z0))
   *'(s(0), s(0)) -> c(+'(0, 0))

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

(152)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
   PROD(cons(x0, nil)) -> c10(*'(x0, s(0)))
   *'(s(0), s(z0)) -> c(+'(*(0, z0), z0))
   *'(s(s(z0)), s(s(z1))) -> c(+'(*(s(z0), s(z1)), s(s(+(z0, z1)))))
   *'(s(s(z0)), s(s(z1))) -> c(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(0))) -> c1(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(z0)), s(s(0))) -> c1(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c1(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c1(*'(s(0), s(z0)))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))))
   *'(s(s(z0)), s(s(0))) -> c3(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))))
   *'(s(s(0)), s(s(z0))) -> c3(*'(s(0), s(z0)))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(0, +(0, z0))), +(s(0), s(z0))))
   SUM(cons(x0, cons(0, x2))) -> c8(+'(x0, sum(x2)), SUM(cons(0, x2)))
   SUM(cons(x0, cons(x1, cons(z0, z1)))) -> c8(+'(x0, +(x1, +(z0, sum(z1)))), SUM(cons(x1, cons(z0, z1))))
   SUM(cons(x0, cons(x1, nil))) -> c8(+'(x0, +(x1, 0)))
   PROD(cons(x0, cons(x1, cons(z0, z1)))) -> c10(*'(x0, *(x1, *(z0, prod(z1)))), PROD(cons(x1, cons(z0, z1))))
   PROD(cons(x0, cons(0, x2))) -> c10(PROD(cons(0, x2)))
   PROD(cons(x0, cons(x1, nil))) -> c4(*'(x0, *(x1, s(0))))
   PROD(cons(x0, cons(x1, nil))) -> c4(PROD(cons(x1, nil)))
S tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
K tuples:
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, *'_2, PROD_1, SUM_1

Compound Symbols:   c2_1, c_1, c10_1, c5_2, c1_1, c3_1, c8_2, c8_1, c10_2, c4_1


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

(153) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace *'(s(0), s(z0)) -> c(+'(*(0, z0), z0)) by 
   *'(s(0), s(0)) -> c(+'(0, 0))
   *'(s(0), s(z0)) -> c(+'(0, z0))

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

(154)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
   PROD(cons(x0, nil)) -> c10(*'(x0, s(0)))
   *'(s(s(z0)), s(s(z1))) -> c(+'(*(s(z0), s(z1)), s(s(+(z0, z1)))))
   *'(s(s(z0)), s(s(z1))) -> c(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(0))) -> c1(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(z0)), s(s(0))) -> c1(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c1(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c1(*'(s(0), s(z0)))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))))
   *'(s(s(z0)), s(s(0))) -> c3(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))))
   *'(s(s(0)), s(s(z0))) -> c3(*'(s(0), s(z0)))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(0, +(0, z0))), +(s(0), s(z0))))
   SUM(cons(x0, cons(0, x2))) -> c8(+'(x0, sum(x2)), SUM(cons(0, x2)))
   SUM(cons(x0, cons(x1, cons(z0, z1)))) -> c8(+'(x0, +(x1, +(z0, sum(z1)))), SUM(cons(x1, cons(z0, z1))))
   SUM(cons(x0, cons(x1, nil))) -> c8(+'(x0, +(x1, 0)))
   PROD(cons(x0, cons(x1, cons(z0, z1)))) -> c10(*'(x0, *(x1, *(z0, prod(z1)))), PROD(cons(x1, cons(z0, z1))))
   PROD(cons(x0, cons(0, x2))) -> c10(PROD(cons(0, x2)))
   PROD(cons(x0, cons(x1, nil))) -> c4(*'(x0, *(x1, s(0))))
   PROD(cons(x0, cons(x1, nil))) -> c4(PROD(cons(x1, nil)))
   *'(s(0), s(0)) -> c(+'(0, 0))
   *'(s(0), s(z0)) -> c(+'(0, z0))
S tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
K tuples:
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, *'_2, PROD_1, SUM_1

Compound Symbols:   c2_1, c_1, c10_1, c5_2, c1_1, c3_1, c8_2, c8_1, c10_2, c4_1


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

(155) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 2 trailing nodes:
   *'(s(0), s(z0)) -> c(+'(0, z0))
   *'(s(0), s(0)) -> c(+'(0, 0))

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

(156)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
   PROD(cons(x0, nil)) -> c10(*'(x0, s(0)))
   *'(s(s(z0)), s(s(z1))) -> c(+'(*(s(z0), s(z1)), s(s(+(z0, z1)))))
   *'(s(s(z0)), s(s(z1))) -> c(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(0))) -> c1(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(z0)), s(s(0))) -> c1(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c1(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c1(*'(s(0), s(z0)))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))))
   *'(s(s(z0)), s(s(0))) -> c3(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))))
   *'(s(s(0)), s(s(z0))) -> c3(*'(s(0), s(z0)))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(0, +(0, z0))), +(s(0), s(z0))))
   SUM(cons(x0, cons(0, x2))) -> c8(+'(x0, sum(x2)), SUM(cons(0, x2)))
   SUM(cons(x0, cons(x1, cons(z0, z1)))) -> c8(+'(x0, +(x1, +(z0, sum(z1)))), SUM(cons(x1, cons(z0, z1))))
   SUM(cons(x0, cons(x1, nil))) -> c8(+'(x0, +(x1, 0)))
   PROD(cons(x0, cons(x1, cons(z0, z1)))) -> c10(*'(x0, *(x1, *(z0, prod(z1)))), PROD(cons(x1, cons(z0, z1))))
   PROD(cons(x0, cons(0, x2))) -> c10(PROD(cons(0, x2)))
   PROD(cons(x0, cons(x1, nil))) -> c4(*'(x0, *(x1, s(0))))
   PROD(cons(x0, cons(x1, nil))) -> c4(PROD(cons(x1, nil)))
S tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
K tuples:
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, *'_2, PROD_1, SUM_1

Compound Symbols:   c2_1, c_1, c10_1, c5_2, c1_1, c3_1, c8_2, c8_1, c10_2, c4_1


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

(157) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace *'(s(s(z0)), s(s(z1))) -> c(+'(*(s(z0), s(z1)), s(s(+(z0, z1))))) by 
   *'(s(s(z0)), s(s(0))) -> c(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))))
   *'(s(s(z0)), s(s(z1))) -> c(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))))

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

(158)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
   PROD(cons(x0, nil)) -> c10(*'(x0, s(0)))
   *'(s(s(z0)), s(s(z1))) -> c(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(0))) -> c1(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(z0)), s(s(0))) -> c1(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c1(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c1(*'(s(0), s(z0)))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))))
   *'(s(s(z0)), s(s(0))) -> c3(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))))
   *'(s(s(0)), s(s(z0))) -> c3(*'(s(0), s(z0)))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(0, +(0, z0))), +(s(0), s(z0))))
   SUM(cons(x0, cons(0, x2))) -> c8(+'(x0, sum(x2)), SUM(cons(0, x2)))
   SUM(cons(x0, cons(x1, cons(z0, z1)))) -> c8(+'(x0, +(x1, +(z0, sum(z1)))), SUM(cons(x1, cons(z0, z1))))
   SUM(cons(x0, cons(x1, nil))) -> c8(+'(x0, +(x1, 0)))
   PROD(cons(x0, cons(x1, cons(z0, z1)))) -> c10(*'(x0, *(x1, *(z0, prod(z1)))), PROD(cons(x1, cons(z0, z1))))
   PROD(cons(x0, cons(0, x2))) -> c10(PROD(cons(0, x2)))
   PROD(cons(x0, cons(x1, nil))) -> c4(*'(x0, *(x1, s(0))))
   PROD(cons(x0, cons(x1, nil))) -> c4(PROD(cons(x1, nil)))
   *'(s(s(z0)), s(s(0))) -> c(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))))
   *'(s(s(z0)), s(s(z1))) -> c(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))))
S tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
K tuples:
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, *'_2, PROD_1, SUM_1

Compound Symbols:   c2_1, c_1, c10_1, c5_2, c1_1, c3_1, c8_2, c8_1, c10_2, c4_1


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

(159) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace *'(s(s(z0)), s(s(z1))) -> c(+'(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))) by 
   *'(s(s(z0)), s(s(z1))) -> c(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))))
   *'(s(s(z0)), s(s(0))) -> c(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))))
   *'(s(s(z0)), s(s(0))) -> c(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c(+'(s(+(0, +(0, z0))), +(s(0), s(z0))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))))

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

(160)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
   PROD(cons(x0, nil)) -> c10(*'(x0, s(0)))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(0))) -> c1(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(z0)), s(s(0))) -> c1(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c1(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c1(*'(s(0), s(z0)))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))))
   *'(s(s(z0)), s(s(0))) -> c3(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))))
   *'(s(s(0)), s(s(z0))) -> c3(*'(s(0), s(z0)))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(0, +(0, z0))), +(s(0), s(z0))))
   SUM(cons(x0, cons(0, x2))) -> c8(+'(x0, sum(x2)), SUM(cons(0, x2)))
   SUM(cons(x0, cons(x1, cons(z0, z1)))) -> c8(+'(x0, +(x1, +(z0, sum(z1)))), SUM(cons(x1, cons(z0, z1))))
   SUM(cons(x0, cons(x1, nil))) -> c8(+'(x0, +(x1, 0)))
   PROD(cons(x0, cons(x1, cons(z0, z1)))) -> c10(*'(x0, *(x1, *(z0, prod(z1)))), PROD(cons(x1, cons(z0, z1))))
   PROD(cons(x0, cons(0, x2))) -> c10(PROD(cons(0, x2)))
   PROD(cons(x0, cons(x1, nil))) -> c4(*'(x0, *(x1, s(0))))
   PROD(cons(x0, cons(x1, nil))) -> c4(PROD(cons(x1, nil)))
   *'(s(s(z0)), s(s(0))) -> c(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))))
   *'(s(s(z0)), s(s(z1))) -> c(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))))
   *'(s(s(z0)), s(s(0))) -> c(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))))
   *'(s(s(z0)), s(s(0))) -> c(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c(+'(s(+(0, +(0, z0))), +(s(0), s(z0))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))))
S tuples:
   +'(s(z0), s(z1)) -> c2(+'(z0, z1))
K tuples:
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   +'_2, *'_2, PROD_1, SUM_1

Compound Symbols:   c2_1, c_1, c10_1, c5_2, c1_1, c3_1, c8_2, c8_1, c10_2, c4_1


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

(161) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace +'(s(z0), s(z1)) -> c2(+'(z0, z1)) by 
   +'(s(s(y0)), s(s(y1))) -> c2(+'(s(y0), s(y1)))

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

(162)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
   PROD(cons(x0, nil)) -> c10(*'(x0, s(0)))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(0))) -> c1(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(z0)), s(s(0))) -> c1(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c1(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c1(*'(s(0), s(z0)))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))))
   *'(s(s(z0)), s(s(0))) -> c3(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))))
   *'(s(s(0)), s(s(z0))) -> c3(*'(s(0), s(z0)))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(0, +(0, z0))), +(s(0), s(z0))))
   SUM(cons(x0, cons(0, x2))) -> c8(+'(x0, sum(x2)), SUM(cons(0, x2)))
   SUM(cons(x0, cons(x1, cons(z0, z1)))) -> c8(+'(x0, +(x1, +(z0, sum(z1)))), SUM(cons(x1, cons(z0, z1))))
   SUM(cons(x0, cons(x1, nil))) -> c8(+'(x0, +(x1, 0)))
   PROD(cons(x0, cons(x1, cons(z0, z1)))) -> c10(*'(x0, *(x1, *(z0, prod(z1)))), PROD(cons(x1, cons(z0, z1))))
   PROD(cons(x0, cons(0, x2))) -> c10(PROD(cons(0, x2)))
   PROD(cons(x0, cons(x1, nil))) -> c4(*'(x0, *(x1, s(0))))
   PROD(cons(x0, cons(x1, nil))) -> c4(PROD(cons(x1, nil)))
   *'(s(s(z0)), s(s(0))) -> c(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))))
   *'(s(s(z0)), s(s(z1))) -> c(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))))
   *'(s(s(z0)), s(s(0))) -> c(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))))
   *'(s(s(z0)), s(s(0))) -> c(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c(+'(s(+(0, +(0, z0))), +(s(0), s(z0))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))))
   +'(s(s(y0)), s(s(y1))) -> c2(+'(s(y0), s(y1)))
S tuples:
   +'(s(s(y0)), s(s(y1))) -> c2(+'(s(y0), s(y1)))
K tuples:
   *'(s(z0), s(z1)) -> c(+'(z0, z1))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   *'_2, PROD_1, SUM_1, +'_2

Compound Symbols:   c_1, c10_1, c5_2, c1_1, c3_1, c8_2, c8_1, c10_2, c4_1, c2_1


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

(163) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace *'(s(z0), s(z1)) -> c(+'(z0, z1)) by 
   *'(s(s(s(y0))), s(s(s(y1)))) -> c(+'(s(s(y0)), s(s(y1))))

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

(164)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   PROD(cons(x0, nil)) -> c10(*'(x0, s(0)))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(0))) -> c1(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(z0)), s(s(0))) -> c1(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c1(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c1(*'(s(0), s(z0)))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))))
   *'(s(s(z0)), s(s(0))) -> c3(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))))
   *'(s(s(0)), s(s(z0))) -> c3(*'(s(0), s(z0)))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(0, +(0, z0))), +(s(0), s(z0))))
   SUM(cons(x0, cons(0, x2))) -> c8(+'(x0, sum(x2)), SUM(cons(0, x2)))
   SUM(cons(x0, cons(x1, cons(z0, z1)))) -> c8(+'(x0, +(x1, +(z0, sum(z1)))), SUM(cons(x1, cons(z0, z1))))
   SUM(cons(x0, cons(x1, nil))) -> c8(+'(x0, +(x1, 0)))
   PROD(cons(x0, cons(x1, cons(z0, z1)))) -> c10(*'(x0, *(x1, *(z0, prod(z1)))), PROD(cons(x1, cons(z0, z1))))
   PROD(cons(x0, cons(0, x2))) -> c10(PROD(cons(0, x2)))
   PROD(cons(x0, cons(x1, nil))) -> c4(*'(x0, *(x1, s(0))))
   PROD(cons(x0, cons(x1, nil))) -> c4(PROD(cons(x1, nil)))
   *'(s(s(z0)), s(s(0))) -> c(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))))
   *'(s(s(z0)), s(s(z1))) -> c(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))))
   *'(s(s(z0)), s(s(0))) -> c(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))))
   *'(s(s(z0)), s(s(0))) -> c(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c(+'(s(+(0, +(0, z0))), +(s(0), s(z0))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))))
   +'(s(s(y0)), s(s(y1))) -> c2(+'(s(y0), s(y1)))
   *'(s(s(s(y0))), s(s(s(y1)))) -> c(+'(s(s(y0)), s(s(y1))))
S tuples:
   +'(s(s(y0)), s(s(y1))) -> c2(+'(s(y0), s(y1)))
K tuples:
   *'(s(s(s(y0))), s(s(s(y1)))) -> c(+'(s(s(y0)), s(s(y1))))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   PROD_1, *'_2, SUM_1, +'_2

Compound Symbols:   c10_1, c5_2, c1_1, c3_1, c8_2, c8_1, c10_2, c4_1, c_1, c2_1


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

(165) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 6 trailing nodes:
   *'(s(s(0)), s(s(z0))) -> c1(*'(s(0), s(z0)))
   *'(s(s(z0)), s(s(0))) -> c1(*'(s(z0), s(0)))
   *'(s(s(z0)), s(s(0))) -> c3(*'(s(z0), s(0)))
   *'(s(s(0)), s(s(z0))) -> c3(*'(s(0), s(z0)))
   PROD(cons(x0, cons(x1, nil))) -> c4(PROD(cons(x1, nil)))
   PROD(cons(x0, nil)) -> c10(*'(x0, s(0)))

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

(166)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(0))) -> c1(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c1(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(0, +(0, z0))), +(s(0), s(z0))))
   SUM(cons(x0, cons(0, x2))) -> c8(+'(x0, sum(x2)), SUM(cons(0, x2)))
   SUM(cons(x0, cons(x1, cons(z0, z1)))) -> c8(+'(x0, +(x1, +(z0, sum(z1)))), SUM(cons(x1, cons(z0, z1))))
   SUM(cons(x0, cons(x1, nil))) -> c8(+'(x0, +(x1, 0)))
   PROD(cons(x0, cons(x1, cons(z0, z1)))) -> c10(*'(x0, *(x1, *(z0, prod(z1)))), PROD(cons(x1, cons(z0, z1))))
   PROD(cons(x0, cons(0, x2))) -> c10(PROD(cons(0, x2)))
   PROD(cons(x0, cons(x1, nil))) -> c4(*'(x0, *(x1, s(0))))
   *'(s(s(z0)), s(s(0))) -> c(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))))
   *'(s(s(z0)), s(s(z1))) -> c(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))))
   *'(s(s(z0)), s(s(0))) -> c(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))))
   *'(s(s(z0)), s(s(0))) -> c(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c(+'(s(+(0, +(0, z0))), +(s(0), s(z0))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))))
   +'(s(s(y0)), s(s(y1))) -> c2(+'(s(y0), s(y1)))
   *'(s(s(s(y0))), s(s(s(y1)))) -> c(+'(s(s(y0)), s(s(y1))))
S tuples:
   +'(s(s(y0)), s(s(y1))) -> c2(+'(s(y0), s(y1)))
K tuples:
   *'(s(s(s(y0))), s(s(s(y1)))) -> c(+'(s(s(y0)), s(s(y1))))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   *'_2, SUM_1, PROD_1, +'_2

Compound Symbols:   c5_2, c1_1, c3_1, c8_2, c8_1, c10_2, c10_1, c4_1, c_1, c2_1


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

(167) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace PROD(cons(x0, cons(0, x2))) -> c10(PROD(cons(0, x2))) by 
   PROD(cons(z0, cons(0, cons(y1, cons(y2, y3))))) -> c10(PROD(cons(0, cons(y1, cons(y2, y3)))))
   PROD(cons(z0, cons(0, cons(0, y1)))) -> c10(PROD(cons(0, cons(0, y1))))
   PROD(cons(z0, cons(0, cons(y1, nil)))) -> c10(PROD(cons(0, cons(y1, nil))))

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

(168)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(0))) -> c1(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c1(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(0, +(0, z0))), +(s(0), s(z0))))
   SUM(cons(x0, cons(0, x2))) -> c8(+'(x0, sum(x2)), SUM(cons(0, x2)))
   SUM(cons(x0, cons(x1, cons(z0, z1)))) -> c8(+'(x0, +(x1, +(z0, sum(z1)))), SUM(cons(x1, cons(z0, z1))))
   SUM(cons(x0, cons(x1, nil))) -> c8(+'(x0, +(x1, 0)))
   PROD(cons(x0, cons(x1, cons(z0, z1)))) -> c10(*'(x0, *(x1, *(z0, prod(z1)))), PROD(cons(x1, cons(z0, z1))))
   PROD(cons(x0, cons(x1, nil))) -> c4(*'(x0, *(x1, s(0))))
   *'(s(s(z0)), s(s(0))) -> c(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))))
   *'(s(s(z0)), s(s(z1))) -> c(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))))
   *'(s(s(z0)), s(s(0))) -> c(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))))
   *'(s(s(z0)), s(s(0))) -> c(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c(+'(s(+(0, +(0, z0))), +(s(0), s(z0))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))))
   +'(s(s(y0)), s(s(y1))) -> c2(+'(s(y0), s(y1)))
   *'(s(s(s(y0))), s(s(s(y1)))) -> c(+'(s(s(y0)), s(s(y1))))
   PROD(cons(z0, cons(0, cons(y1, cons(y2, y3))))) -> c10(PROD(cons(0, cons(y1, cons(y2, y3)))))
   PROD(cons(z0, cons(0, cons(0, y1)))) -> c10(PROD(cons(0, cons(0, y1))))
   PROD(cons(z0, cons(0, cons(y1, nil)))) -> c10(PROD(cons(0, cons(y1, nil))))
S tuples:
   +'(s(s(y0)), s(s(y1))) -> c2(+'(s(y0), s(y1)))
K tuples:
   *'(s(s(s(y0))), s(s(s(y1)))) -> c(+'(s(s(y0)), s(s(y1))))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   *'_2, SUM_1, PROD_1, +'_2

Compound Symbols:   c5_2, c1_1, c3_1, c8_2, c8_1, c10_2, c4_1, c_1, c2_1, c10_1


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

(169) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace +'(s(s(y0)), s(s(y1))) -> c2(+'(s(y0), s(y1))) by 
   +'(s(s(s(y0))), s(s(s(y1)))) -> c2(+'(s(s(y0)), s(s(y1))))

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

(170)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(0))) -> c1(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c1(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(0, +(0, z0))), +(s(0), s(z0))))
   SUM(cons(x0, cons(0, x2))) -> c8(+'(x0, sum(x2)), SUM(cons(0, x2)))
   SUM(cons(x0, cons(x1, cons(z0, z1)))) -> c8(+'(x0, +(x1, +(z0, sum(z1)))), SUM(cons(x1, cons(z0, z1))))
   SUM(cons(x0, cons(x1, nil))) -> c8(+'(x0, +(x1, 0)))
   PROD(cons(x0, cons(x1, cons(z0, z1)))) -> c10(*'(x0, *(x1, *(z0, prod(z1)))), PROD(cons(x1, cons(z0, z1))))
   PROD(cons(x0, cons(x1, nil))) -> c4(*'(x0, *(x1, s(0))))
   *'(s(s(z0)), s(s(0))) -> c(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))))
   *'(s(s(z0)), s(s(z1))) -> c(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))))
   *'(s(s(z0)), s(s(0))) -> c(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))))
   *'(s(s(z0)), s(s(0))) -> c(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c(+'(s(+(0, +(0, z0))), +(s(0), s(z0))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))))
   *'(s(s(s(y0))), s(s(s(y1)))) -> c(+'(s(s(y0)), s(s(y1))))
   PROD(cons(z0, cons(0, cons(y1, cons(y2, y3))))) -> c10(PROD(cons(0, cons(y1, cons(y2, y3)))))
   PROD(cons(z0, cons(0, cons(0, y1)))) -> c10(PROD(cons(0, cons(0, y1))))
   PROD(cons(z0, cons(0, cons(y1, nil)))) -> c10(PROD(cons(0, cons(y1, nil))))
   +'(s(s(s(y0))), s(s(s(y1)))) -> c2(+'(s(s(y0)), s(s(y1))))
S tuples:
   +'(s(s(s(y0))), s(s(s(y1)))) -> c2(+'(s(s(y0)), s(s(y1))))
K tuples:
   *'(s(s(s(y0))), s(s(s(y1)))) -> c(+'(s(s(y0)), s(s(y1))))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   *'_2, SUM_1, PROD_1, +'_2

Compound Symbols:   c5_2, c1_1, c3_1, c8_2, c8_1, c10_2, c4_1, c_1, c10_1, c2_1


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

(171) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace *'(s(s(s(y0))), s(s(s(y1)))) -> c(+'(s(s(y0)), s(s(y1)))) by 
   *'(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c(+'(s(s(s(y0))), s(s(s(y1)))))

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

(172)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(0))) -> c1(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c1(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(0, +(0, z0))), +(s(0), s(z0))))
   SUM(cons(x0, cons(0, x2))) -> c8(+'(x0, sum(x2)), SUM(cons(0, x2)))
   SUM(cons(x0, cons(x1, cons(z0, z1)))) -> c8(+'(x0, +(x1, +(z0, sum(z1)))), SUM(cons(x1, cons(z0, z1))))
   SUM(cons(x0, cons(x1, nil))) -> c8(+'(x0, +(x1, 0)))
   PROD(cons(x0, cons(x1, cons(z0, z1)))) -> c10(*'(x0, *(x1, *(z0, prod(z1)))), PROD(cons(x1, cons(z0, z1))))
   PROD(cons(x0, cons(x1, nil))) -> c4(*'(x0, *(x1, s(0))))
   *'(s(s(z0)), s(s(0))) -> c(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))))
   *'(s(s(z0)), s(s(z1))) -> c(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))))
   *'(s(s(z0)), s(s(0))) -> c(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))))
   *'(s(s(z0)), s(s(0))) -> c(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c(+'(s(+(0, +(0, z0))), +(s(0), s(z0))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))))
   PROD(cons(z0, cons(0, cons(y1, cons(y2, y3))))) -> c10(PROD(cons(0, cons(y1, cons(y2, y3)))))
   PROD(cons(z0, cons(0, cons(0, y1)))) -> c10(PROD(cons(0, cons(0, y1))))
   PROD(cons(z0, cons(0, cons(y1, nil)))) -> c10(PROD(cons(0, cons(y1, nil))))
   +'(s(s(s(y0))), s(s(s(y1)))) -> c2(+'(s(s(y0)), s(s(y1))))
   *'(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c(+'(s(s(s(y0))), s(s(s(y1)))))
S tuples:
   +'(s(s(s(y0))), s(s(s(y1)))) -> c2(+'(s(s(y0)), s(s(y1))))
K tuples:
   *'(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c(+'(s(s(s(y0))), s(s(s(y1)))))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   *'_2, SUM_1, PROD_1, +'_2

Compound Symbols:   c5_2, c1_1, c3_1, c8_2, c8_1, c10_2, c4_1, c_1, c10_1, c2_1


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

(173) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace PROD(cons(z0, cons(0, cons(0, y1)))) -> c10(PROD(cons(0, cons(0, y1)))) by 
   PROD(cons(z0, cons(0, cons(0, cons(y2, y3))))) -> c10(PROD(cons(0, cons(0, cons(y2, y3)))))
   PROD(cons(z0, cons(0, cons(0, nil)))) -> c10(PROD(cons(0, cons(0, nil))))
   PROD(cons(z0, cons(0, cons(0, cons(y1, cons(y2, y3)))))) -> c10(PROD(cons(0, cons(0, cons(y1, cons(y2, y3))))))
   PROD(cons(z0, cons(0, cons(0, cons(0, y1))))) -> c10(PROD(cons(0, cons(0, cons(0, y1)))))
   PROD(cons(z0, cons(0, cons(0, cons(y1, nil))))) -> c10(PROD(cons(0, cons(0, cons(y1, nil)))))

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

(174)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   +(z0, 0) -> z0
   +(0, z0) -> z0
   +(s(z0), s(z1)) -> s(s(+(z0, z1)))
   *(z0, 0) -> 0
   *(0, z0) -> 0
   *(s(z0), s(z1)) -> s(+(*(z0, z1), +(z0, z1)))
   sum(nil) -> 0
   sum(cons(z0, z1)) -> +(z0, sum(z1))
   prod(nil) -> s(0)
   prod(cons(z0, z1)) -> *(z0, prod(z1))
Tuples:
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(z1))) -> c5(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))), *'(s(z0), s(z1)))
   *'(s(s(z0)), s(s(0))) -> c1(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c1(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c5(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))), *'(s(s(z0)), s(s(z1))))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))))
   *'(s(s(z0)), s(s(0))) -> c3(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c3(+'(s(+(0, +(0, z0))), +(s(0), s(z0))))
   SUM(cons(x0, cons(0, x2))) -> c8(+'(x0, sum(x2)), SUM(cons(0, x2)))
   SUM(cons(x0, cons(x1, cons(z0, z1)))) -> c8(+'(x0, +(x1, +(z0, sum(z1)))), SUM(cons(x1, cons(z0, z1))))
   SUM(cons(x0, cons(x1, nil))) -> c8(+'(x0, +(x1, 0)))
   PROD(cons(x0, cons(x1, cons(z0, z1)))) -> c10(*'(x0, *(x1, *(z0, prod(z1)))), PROD(cons(x1, cons(z0, z1))))
   PROD(cons(x0, cons(x1, nil))) -> c4(*'(x0, *(x1, s(0))))
   *'(s(s(z0)), s(s(0))) -> c(+'(*(s(z0), s(0)), s(s(z0))))
   *'(s(s(0)), s(s(z0))) -> c(+'(*(s(0), s(z0)), s(s(z0))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c(+'(*(s(s(z0)), s(s(z1))), s(s(s(s(+(z0, z1)))))))
   *'(s(s(z0)), s(s(z1))) -> c(+'(s(+(*(z0, z1), +(z0, z1))), s(s(+(z0, z1)))))
   *'(s(s(z0)), s(s(0))) -> c(+'(s(+(*(z0, 0), z0)), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c(+'(s(+(*(0, z0), z0)), +(s(0), s(z0))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c(+'(s(+(*(s(z0), s(z1)), s(s(+(z0, z1))))), +(s(s(z0)), s(s(z1)))))
   *'(s(s(z0)), s(s(0))) -> c(+'(s(+(0, +(z0, 0))), +(s(z0), s(0))))
   *'(s(s(0)), s(s(z0))) -> c(+'(s(+(0, +(0, z0))), +(s(0), s(z0))))
   *'(s(s(s(z0))), s(s(s(z1)))) -> c(+'(s(+(s(+(*(z0, z1), +(z0, z1))), +(s(z0), s(z1)))), +(s(s(z0)), s(s(z1)))))
   PROD(cons(z0, cons(0, cons(y1, cons(y2, y3))))) -> c10(PROD(cons(0, cons(y1, cons(y2, y3)))))
   PROD(cons(z0, cons(0, cons(y1, nil)))) -> c10(PROD(cons(0, cons(y1, nil))))
   +'(s(s(s(y0))), s(s(s(y1)))) -> c2(+'(s(s(y0)), s(s(y1))))
   *'(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c(+'(s(s(s(y0))), s(s(s(y1)))))
   PROD(cons(z0, cons(0, cons(0, cons(y2, y3))))) -> c10(PROD(cons(0, cons(0, cons(y2, y3)))))
   PROD(cons(z0, cons(0, cons(0, nil)))) -> c10(PROD(cons(0, cons(0, nil))))
   PROD(cons(z0, cons(0, cons(0, cons(y1, cons(y2, y3)))))) -> c10(PROD(cons(0, cons(0, cons(y1, cons(y2, y3))))))
   PROD(cons(z0, cons(0, cons(0, cons(0, y1))))) -> c10(PROD(cons(0, cons(0, cons(0, y1)))))
   PROD(cons(z0, cons(0, cons(0, cons(y1, nil))))) -> c10(PROD(cons(0, cons(0, cons(y1, nil)))))
S tuples:
   +'(s(s(s(y0))), s(s(s(y1)))) -> c2(+'(s(s(y0)), s(s(y1))))
K tuples:
   *'(s(s(s(s(y0)))), s(s(s(s(y1))))) -> c(+'(s(s(s(y0))), s(s(s(y1)))))
Defined Rule Symbols:   +_2, *_2, sum_1, prod_1

Defined Pair Symbols:   *'_2, SUM_1, PROD_1, +'_2

Compound Symbols:   c5_2, c1_1, c3_1, c8_2, c8_1, c10_2, c4_1, c_1, c10_1, c2_1


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

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

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

   +(x, 0) -> x [1]
   +(0, x) -> x [1]
   +(s(x), s(y)) -> s(s(+(x, y))) [1]
   *(x, 0) -> 0 [1]
   *(0, x) -> 0 [1]
   *(s(x), s(y)) -> s(+(*(x, y), +(x, y))) [1]
   sum(nil) -> 0 [1]
   sum(cons(x, l)) -> +(x, sum(l)) [1]
   prod(nil) -> s(0) [1]
   prod(cons(x, l)) -> *(x, prod(l)) [1]

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

(177) CpxWeightedTrsRenamingProof (BOTH BOUNDS(ID, ID))
Renamed defined symbols to avoid conflicts with arithmetic symbols:

+ => plus
* => times

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

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

   plus(x, 0) -> x [1]
   plus(0, x) -> x [1]
   plus(s(x), s(y)) -> s(s(plus(x, y))) [1]
   times(x, 0) -> 0 [1]
   times(0, x) -> 0 [1]
   times(s(x), s(y)) -> s(plus(times(x, y), plus(x, y))) [1]
   sum(nil) -> 0 [1]
   sum(cons(x, l)) -> plus(x, sum(l)) [1]
   prod(nil) -> s(0) [1]
   prod(cons(x, l)) -> times(x, prod(l)) [1]

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

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

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

   plus(x, 0) -> x [1]
   plus(0, x) -> x [1]
   plus(s(x), s(y)) -> s(s(plus(x, y))) [1]
   times(x, 0) -> 0 [1]
   times(0, x) -> 0 [1]
   times(s(x), s(y)) -> s(plus(times(x, y), plus(x, y))) [1]
   sum(nil) -> 0 [1]
   sum(cons(x, l)) -> plus(x, sum(l)) [1]
   prod(nil) -> s(0) [1]
   prod(cons(x, l)) -> times(x, prod(l)) [1]

The TRS has the following type information:
plus :: 0:s -> 0:s -> 0:s
0 :: 0:s
s :: 0:s -> 0:s
times :: 0:s -> 0:s -> 0:s
sum :: nil:cons -> 0:s
nil :: nil:cons
cons :: 0:s -> nil:cons -> nil:cons
prod :: nil:cons -> 0:s

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

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

   times_2
   plus_2
   prod_1
   sum_1

Due to the following rules being added:
none

And the following fresh constants: none

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

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

   plus(x, 0) -> x [1]
   plus(0, x) -> x [1]
   plus(s(x), s(y)) -> s(s(plus(x, y))) [1]
   times(x, 0) -> 0 [1]
   times(0, x) -> 0 [1]
   times(s(x), s(y)) -> s(plus(times(x, y), plus(x, y))) [1]
   sum(nil) -> 0 [1]
   sum(cons(x, l)) -> plus(x, sum(l)) [1]
   prod(nil) -> s(0) [1]
   prod(cons(x, l)) -> times(x, prod(l)) [1]

The TRS has the following type information:
plus :: 0:s -> 0:s -> 0:s
0 :: 0:s
s :: 0:s -> 0:s
times :: 0:s -> 0:s -> 0:s
sum :: nil:cons -> 0:s
nil :: nil:cons
cons :: 0:s -> nil:cons -> nil:cons
prod :: nil:cons -> 0:s

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

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

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

   plus(x, 0) -> x [1]
   plus(0, x) -> x [1]
   plus(s(x), s(y)) -> s(s(plus(x, y))) [1]
   times(x, 0) -> 0 [1]
   times(0, x) -> 0 [1]
   times(s(x), s(0)) -> s(plus(0, x)) [3]
   times(s(0), s(0)) -> s(plus(0, 0)) [3]
   times(s(0), s(0)) -> s(plus(0, 0)) [3]
   times(s(0), s(y)) -> s(plus(0, y)) [3]
   times(s(s(x')), s(s(y'))) -> s(plus(s(plus(times(x', y'), plus(x', y'))), s(s(plus(x', y'))))) [3]
   sum(nil) -> 0 [1]
   sum(cons(x, nil)) -> plus(x, 0) [2]
   sum(cons(x, cons(x'', l'))) -> plus(x, plus(x'', sum(l'))) [2]
   prod(nil) -> s(0) [1]
   prod(cons(x, nil)) -> times(x, s(0)) [2]
   prod(cons(x, cons(x1, l''))) -> times(x, times(x1, prod(l''))) [2]

The TRS has the following type information:
plus :: 0:s -> 0:s -> 0:s
0 :: 0:s
s :: 0:s -> 0:s
times :: 0:s -> 0:s -> 0:s
sum :: nil:cons -> 0:s
nil :: nil:cons
cons :: 0:s -> nil:cons -> nil:cons
prod :: nil:cons -> 0:s

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

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

   0 => 0
   nil => 0

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

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

   plus(z, z') -{ 1 }-> x :|: x >= 0, z = x, z' = 0
   plus(z, z') -{ 1 }-> x :|: z' = x, x >= 0, z = 0
   plus(z, z') -{ 1 }-> 1 + (1 + plus(x, y)) :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x
   prod(z) -{ 2 }-> times(x, times(x1, prod(l''))) :|: z = 1 + x + (1 + x1 + l''), x1 >= 0, l'' >= 0, x >= 0
   prod(z) -{ 2 }-> times(x, 1 + 0) :|: x >= 0, z = 1 + x + 0
   prod(z) -{ 1 }-> 1 + 0 :|: z = 0
   sum(z) -{ 2 }-> plus(x, plus(x'', sum(l'))) :|: x >= 0, l' >= 0, x'' >= 0, z = 1 + x + (1 + x'' + l')
   sum(z) -{ 2 }-> plus(x, 0) :|: x >= 0, z = 1 + x + 0
   sum(z) -{ 1 }-> 0 :|: z = 0
   times(z, z') -{ 1 }-> 0 :|: x >= 0, z = x, z' = 0
   times(z, z') -{ 1 }-> 0 :|: z' = x, x >= 0, z = 0
   times(z, z') -{ 3 }-> 1 + plus(0, x) :|: x >= 0, z' = 1 + 0, z = 1 + x
   times(z, z') -{ 3 }-> 1 + plus(0, y) :|: z' = 1 + y, z = 1 + 0, y >= 0
   times(z, z') -{ 3 }-> 1 + plus(0, 0) :|: z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 3 }-> 1 + plus(1 + plus(times(x', y'), plus(x', y')), 1 + (1 + plus(x', y'))) :|: z' = 1 + (1 + y'), x' >= 0, y' >= 0, z = 1 + (1 + x')


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

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

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

   plus(z, z') -{ 1 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 1 }-> 1 + (1 + plus(z - 1, z' - 1)) :|: z - 1 >= 0, z' - 1 >= 0
   prod(z) -{ 2 }-> times(x, times(x1, prod(l''))) :|: z = 1 + x + (1 + x1 + l''), x1 >= 0, l'' >= 0, x >= 0
   prod(z) -{ 2 }-> times(z - 1, 1 + 0) :|: z - 1 >= 0
   prod(z) -{ 1 }-> 1 + 0 :|: z = 0
   sum(z) -{ 2 }-> plus(x, plus(x'', sum(l'))) :|: x >= 0, l' >= 0, x'' >= 0, z = 1 + x + (1 + x'' + l')
   sum(z) -{ 2 }-> plus(z - 1, 0) :|: z - 1 >= 0
   sum(z) -{ 1 }-> 0 :|: z = 0
   times(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 3 }-> 1 + plus(0, 0) :|: z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 3 }-> 1 + plus(0, z - 1) :|: z - 1 >= 0, z' = 1 + 0
   times(z, z') -{ 3 }-> 1 + plus(0, z' - 1) :|: z = 1 + 0, z' - 1 >= 0
   times(z, z') -{ 3 }-> 1 + plus(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 1 + (1 + plus(z - 2, z' - 2))) :|: z - 2 >= 0, z' - 2 >= 0


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

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

   { plus }
   { times }
   { sum }
   { prod }

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

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

   plus(z, z') -{ 1 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 1 }-> 1 + (1 + plus(z - 1, z' - 1)) :|: z - 1 >= 0, z' - 1 >= 0
   prod(z) -{ 2 }-> times(x, times(x1, prod(l''))) :|: z = 1 + x + (1 + x1 + l''), x1 >= 0, l'' >= 0, x >= 0
   prod(z) -{ 2 }-> times(z - 1, 1 + 0) :|: z - 1 >= 0
   prod(z) -{ 1 }-> 1 + 0 :|: z = 0
   sum(z) -{ 2 }-> plus(x, plus(x'', sum(l'))) :|: x >= 0, l' >= 0, x'' >= 0, z = 1 + x + (1 + x'' + l')
   sum(z) -{ 2 }-> plus(z - 1, 0) :|: z - 1 >= 0
   sum(z) -{ 1 }-> 0 :|: z = 0
   times(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 3 }-> 1 + plus(0, 0) :|: z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 3 }-> 1 + plus(0, z - 1) :|: z - 1 >= 0, z' = 1 + 0
   times(z, z') -{ 3 }-> 1 + plus(0, z' - 1) :|: z = 1 + 0, z' - 1 >= 0
   times(z, z') -{ 3 }-> 1 + plus(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 1 + (1 + plus(z - 2, z' - 2))) :|: z - 2 >= 0, z' - 2 >= 0

Function symbols to be analyzed: {plus}, {times}, {sum}, {prod}

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

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

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

   plus(z, z') -{ 1 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 1 }-> 1 + (1 + plus(z - 1, z' - 1)) :|: z - 1 >= 0, z' - 1 >= 0
   prod(z) -{ 2 }-> times(x, times(x1, prod(l''))) :|: z = 1 + x + (1 + x1 + l''), x1 >= 0, l'' >= 0, x >= 0
   prod(z) -{ 2 }-> times(z - 1, 1 + 0) :|: z - 1 >= 0
   prod(z) -{ 1 }-> 1 + 0 :|: z = 0
   sum(z) -{ 2 }-> plus(x, plus(x'', sum(l'))) :|: x >= 0, l' >= 0, x'' >= 0, z = 1 + x + (1 + x'' + l')
   sum(z) -{ 2 }-> plus(z - 1, 0) :|: z - 1 >= 0
   sum(z) -{ 1 }-> 0 :|: z = 0
   times(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 3 }-> 1 + plus(0, 0) :|: z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 3 }-> 1 + plus(0, z - 1) :|: z - 1 >= 0, z' = 1 + 0
   times(z, z') -{ 3 }-> 1 + plus(0, z' - 1) :|: z = 1 + 0, z' - 1 >= 0
   times(z, z') -{ 3 }-> 1 + plus(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 1 + (1 + plus(z - 2, z' - 2))) :|: z - 2 >= 0, z' - 2 >= 0

Function symbols to be analyzed: {plus}, {times}, {sum}, {prod}

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

(193) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   plus(z, z') -{ 1 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 1 }-> 1 + (1 + plus(z - 1, z' - 1)) :|: z - 1 >= 0, z' - 1 >= 0
   prod(z) -{ 2 }-> times(x, times(x1, prod(l''))) :|: z = 1 + x + (1 + x1 + l''), x1 >= 0, l'' >= 0, x >= 0
   prod(z) -{ 2 }-> times(z - 1, 1 + 0) :|: z - 1 >= 0
   prod(z) -{ 1 }-> 1 + 0 :|: z = 0
   sum(z) -{ 2 }-> plus(x, plus(x'', sum(l'))) :|: x >= 0, l' >= 0, x'' >= 0, z = 1 + x + (1 + x'' + l')
   sum(z) -{ 2 }-> plus(z - 1, 0) :|: z - 1 >= 0
   sum(z) -{ 1 }-> 0 :|: z = 0
   times(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 3 }-> 1 + plus(0, 0) :|: z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 3 }-> 1 + plus(0, z - 1) :|: z - 1 >= 0, z' = 1 + 0
   times(z, z') -{ 3 }-> 1 + plus(0, z' - 1) :|: z = 1 + 0, z' - 1 >= 0
   times(z, z') -{ 3 }-> 1 + plus(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 1 + (1 + plus(z - 2, z' - 2))) :|: z - 2 >= 0, z' - 2 >= 0

Function symbols to be analyzed: {plus}, {times}, {sum}, {prod}
Previous analysis results are:
  plus: runtime: ?, size: O(n^1) [z + z']

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

(195) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   plus(z, z') -{ 1 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 1 }-> 1 + (1 + plus(z - 1, z' - 1)) :|: z - 1 >= 0, z' - 1 >= 0
   prod(z) -{ 2 }-> times(x, times(x1, prod(l''))) :|: z = 1 + x + (1 + x1 + l''), x1 >= 0, l'' >= 0, x >= 0
   prod(z) -{ 2 }-> times(z - 1, 1 + 0) :|: z - 1 >= 0
   prod(z) -{ 1 }-> 1 + 0 :|: z = 0
   sum(z) -{ 2 }-> plus(x, plus(x'', sum(l'))) :|: x >= 0, l' >= 0, x'' >= 0, z = 1 + x + (1 + x'' + l')
   sum(z) -{ 2 }-> plus(z - 1, 0) :|: z - 1 >= 0
   sum(z) -{ 1 }-> 0 :|: z = 0
   times(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 3 }-> 1 + plus(0, 0) :|: z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 3 }-> 1 + plus(0, z - 1) :|: z - 1 >= 0, z' = 1 + 0
   times(z, z') -{ 3 }-> 1 + plus(0, z' - 1) :|: z = 1 + 0, z' - 1 >= 0
   times(z, z') -{ 3 }-> 1 + plus(1 + plus(times(z - 2, z' - 2), plus(z - 2, z' - 2)), 1 + (1 + plus(z - 2, z' - 2))) :|: z - 2 >= 0, z' - 2 >= 0

Function symbols to be analyzed: {times}, {sum}, {prod}
Previous analysis results are:
  plus: runtime: O(n^1) [2 + z'], size: O(n^1) [z + z']

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

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

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

   plus(z, z') -{ 1 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 2 + z' }-> 1 + (1 + s) :|: s >= 0, s <= z - 1 + (z' - 1), z - 1 >= 0, z' - 1 >= 0
   prod(z) -{ 2 }-> times(x, times(x1, prod(l''))) :|: z = 1 + x + (1 + x1 + l''), x1 >= 0, l'' >= 0, x >= 0
   prod(z) -{ 2 }-> times(z - 1, 1 + 0) :|: z - 1 >= 0
   prod(z) -{ 1 }-> 1 + 0 :|: z = 0
   sum(z) -{ 4 }-> s4 :|: s4 >= 0, s4 <= z - 1 + 0, z - 1 >= 0
   sum(z) -{ 2 }-> plus(x, plus(x'', sum(l'))) :|: x >= 0, l' >= 0, x'' >= 0, z = 1 + x + (1 + x'' + l')
   sum(z) -{ 1 }-> 0 :|: z = 0
   times(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 4 + z }-> 1 + s' :|: s' >= 0, s' <= 0 + (z - 1), z - 1 >= 0, z' = 1 + 0
   times(z, z') -{ 5 }-> 1 + s'' :|: s'' >= 0, s'' <= 0 + 0, z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 4 + z' }-> 1 + s1 :|: s1 >= 0, s1 <= 0 + (z' - 1), z = 1 + 0, z' - 1 >= 0
   times(z, z') -{ 3 + 2*z' }-> 1 + plus(1 + plus(times(z - 2, z' - 2), s2), 1 + (1 + s3)) :|: s2 >= 0, s2 <= z - 2 + (z' - 2), s3 >= 0, s3 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0

Function symbols to be analyzed: {times}, {sum}, {prod}
Previous analysis results are:
  plus: runtime: O(n^1) [2 + z'], size: O(n^1) [z + z']

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

(199) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   plus(z, z') -{ 1 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 2 + z' }-> 1 + (1 + s) :|: s >= 0, s <= z - 1 + (z' - 1), z - 1 >= 0, z' - 1 >= 0
   prod(z) -{ 2 }-> times(x, times(x1, prod(l''))) :|: z = 1 + x + (1 + x1 + l''), x1 >= 0, l'' >= 0, x >= 0
   prod(z) -{ 2 }-> times(z - 1, 1 + 0) :|: z - 1 >= 0
   prod(z) -{ 1 }-> 1 + 0 :|: z = 0
   sum(z) -{ 4 }-> s4 :|: s4 >= 0, s4 <= z - 1 + 0, z - 1 >= 0
   sum(z) -{ 2 }-> plus(x, plus(x'', sum(l'))) :|: x >= 0, l' >= 0, x'' >= 0, z = 1 + x + (1 + x'' + l')
   sum(z) -{ 1 }-> 0 :|: z = 0
   times(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 4 + z }-> 1 + s' :|: s' >= 0, s' <= 0 + (z - 1), z - 1 >= 0, z' = 1 + 0
   times(z, z') -{ 5 }-> 1 + s'' :|: s'' >= 0, s'' <= 0 + 0, z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 4 + z' }-> 1 + s1 :|: s1 >= 0, s1 <= 0 + (z' - 1), z = 1 + 0, z' - 1 >= 0
   times(z, z') -{ 3 + 2*z' }-> 1 + plus(1 + plus(times(z - 2, z' - 2), s2), 1 + (1 + s3)) :|: s2 >= 0, s2 <= z - 2 + (z' - 2), s3 >= 0, s3 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0

Function symbols to be analyzed: {times}, {sum}, {prod}
Previous analysis results are:
  plus: runtime: O(n^1) [2 + z'], size: O(n^1) [z + z']
  times: runtime: ?, size: O(n^2) [3 + 5*z + 2*z*z' + 2*z^2 + z']

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

(201) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   plus(z, z') -{ 1 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 2 + z' }-> 1 + (1 + s) :|: s >= 0, s <= z - 1 + (z' - 1), z - 1 >= 0, z' - 1 >= 0
   prod(z) -{ 2 }-> times(x, times(x1, prod(l''))) :|: z = 1 + x + (1 + x1 + l''), x1 >= 0, l'' >= 0, x >= 0
   prod(z) -{ 2 }-> times(z - 1, 1 + 0) :|: z - 1 >= 0
   prod(z) -{ 1 }-> 1 + 0 :|: z = 0
   sum(z) -{ 4 }-> s4 :|: s4 >= 0, s4 <= z - 1 + 0, z - 1 >= 0
   sum(z) -{ 2 }-> plus(x, plus(x'', sum(l'))) :|: x >= 0, l' >= 0, x'' >= 0, z = 1 + x + (1 + x'' + l')
   sum(z) -{ 1 }-> 0 :|: z = 0
   times(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 4 + z }-> 1 + s' :|: s' >= 0, s' <= 0 + (z - 1), z - 1 >= 0, z' = 1 + 0
   times(z, z') -{ 5 }-> 1 + s'' :|: s'' >= 0, s'' <= 0 + 0, z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 4 + z' }-> 1 + s1 :|: s1 >= 0, s1 <= 0 + (z' - 1), z = 1 + 0, z' - 1 >= 0
   times(z, z') -{ 3 + 2*z' }-> 1 + plus(1 + plus(times(z - 2, z' - 2), s2), 1 + (1 + s3)) :|: s2 >= 0, s2 <= z - 2 + (z' - 2), s3 >= 0, s3 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0

Function symbols to be analyzed: {sum}, {prod}
Previous analysis results are:
  plus: runtime: O(n^1) [2 + z'], size: O(n^1) [z + z']
  times: runtime: O(n^2) [15 + 2*z + 4*z*z' + 2*z^2 + z'], size: O(n^2) [3 + 5*z + 2*z*z' + 2*z^2 + z']

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

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

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

   plus(z, z') -{ 1 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 2 + z' }-> 1 + (1 + s) :|: s >= 0, s <= z - 1 + (z' - 1), z - 1 >= 0, z' - 1 >= 0
   prod(z) -{ 14 + 2*z + 2*z^2 }-> s8 :|: s8 >= 0, s8 <= 5 * (z - 1) + (1 + 0) + 2 * ((1 + 0) * (z - 1)) + 2 * ((z - 1) * (z - 1)) + 3, z - 1 >= 0
   prod(z) -{ 2 }-> times(x, times(x1, prod(l''))) :|: z = 1 + x + (1 + x1 + l''), x1 >= 0, l'' >= 0, x >= 0
   prod(z) -{ 1 }-> 1 + 0 :|: z = 0
   sum(z) -{ 4 }-> s4 :|: s4 >= 0, s4 <= z - 1 + 0, z - 1 >= 0
   sum(z) -{ 2 }-> plus(x, plus(x'', sum(l'))) :|: x >= 0, l' >= 0, x'' >= 0, z = 1 + x + (1 + x'' + l')
   sum(z) -{ 1 }-> 0 :|: z = 0
   times(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 4 + z }-> 1 + s' :|: s' >= 0, s' <= 0 + (z - 1), z - 1 >= 0, z' = 1 + 0
   times(z, z') -{ 5 }-> 1 + s'' :|: s'' >= 0, s'' <= 0 + 0, z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 4 + z' }-> 1 + s1 :|: s1 >= 0, s1 <= 0 + (z' - 1), z = 1 + 0, z' - 1 >= 0
   times(z, z') -{ 42 + s2 + s3 + -14*z + 4*z*z' + 2*z^2 + -5*z' }-> 1 + s7 :|: s5 >= 0, s5 <= 5 * (z - 2) + (z' - 2) + 2 * ((z' - 2) * (z - 2)) + 2 * ((z - 2) * (z - 2)) + 3, s6 >= 0, s6 <= s5 + s2, s7 >= 0, s7 <= 1 + s6 + (1 + (1 + s3)), s2 >= 0, s2 <= z - 2 + (z' - 2), s3 >= 0, s3 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0

Function symbols to be analyzed: {sum}, {prod}
Previous analysis results are:
  plus: runtime: O(n^1) [2 + z'], size: O(n^1) [z + z']
  times: runtime: O(n^2) [15 + 2*z + 4*z*z' + 2*z^2 + z'], size: O(n^2) [3 + 5*z + 2*z*z' + 2*z^2 + z']

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

(205) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   plus(z, z') -{ 1 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 2 + z' }-> 1 + (1 + s) :|: s >= 0, s <= z - 1 + (z' - 1), z - 1 >= 0, z' - 1 >= 0
   prod(z) -{ 14 + 2*z + 2*z^2 }-> s8 :|: s8 >= 0, s8 <= 5 * (z - 1) + (1 + 0) + 2 * ((1 + 0) * (z - 1)) + 2 * ((z - 1) * (z - 1)) + 3, z - 1 >= 0
   prod(z) -{ 2 }-> times(x, times(x1, prod(l''))) :|: z = 1 + x + (1 + x1 + l''), x1 >= 0, l'' >= 0, x >= 0
   prod(z) -{ 1 }-> 1 + 0 :|: z = 0
   sum(z) -{ 4 }-> s4 :|: s4 >= 0, s4 <= z - 1 + 0, z - 1 >= 0
   sum(z) -{ 2 }-> plus(x, plus(x'', sum(l'))) :|: x >= 0, l' >= 0, x'' >= 0, z = 1 + x + (1 + x'' + l')
   sum(z) -{ 1 }-> 0 :|: z = 0
   times(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 4 + z }-> 1 + s' :|: s' >= 0, s' <= 0 + (z - 1), z - 1 >= 0, z' = 1 + 0
   times(z, z') -{ 5 }-> 1 + s'' :|: s'' >= 0, s'' <= 0 + 0, z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 4 + z' }-> 1 + s1 :|: s1 >= 0, s1 <= 0 + (z' - 1), z = 1 + 0, z' - 1 >= 0
   times(z, z') -{ 42 + s2 + s3 + -14*z + 4*z*z' + 2*z^2 + -5*z' }-> 1 + s7 :|: s5 >= 0, s5 <= 5 * (z - 2) + (z' - 2) + 2 * ((z' - 2) * (z - 2)) + 2 * ((z - 2) * (z - 2)) + 3, s6 >= 0, s6 <= s5 + s2, s7 >= 0, s7 <= 1 + s6 + (1 + (1 + s3)), s2 >= 0, s2 <= z - 2 + (z' - 2), s3 >= 0, s3 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0

Function symbols to be analyzed: {sum}, {prod}
Previous analysis results are:
  plus: runtime: O(n^1) [2 + z'], size: O(n^1) [z + z']
  times: runtime: O(n^2) [15 + 2*z + 4*z*z' + 2*z^2 + z'], size: O(n^2) [3 + 5*z + 2*z*z' + 2*z^2 + z']
  sum: runtime: ?, size: O(n^1) [z]

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

(207) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   plus(z, z') -{ 1 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 2 + z' }-> 1 + (1 + s) :|: s >= 0, s <= z - 1 + (z' - 1), z - 1 >= 0, z' - 1 >= 0
   prod(z) -{ 14 + 2*z + 2*z^2 }-> s8 :|: s8 >= 0, s8 <= 5 * (z - 1) + (1 + 0) + 2 * ((1 + 0) * (z - 1)) + 2 * ((z - 1) * (z - 1)) + 3, z - 1 >= 0
   prod(z) -{ 2 }-> times(x, times(x1, prod(l''))) :|: z = 1 + x + (1 + x1 + l''), x1 >= 0, l'' >= 0, x >= 0
   prod(z) -{ 1 }-> 1 + 0 :|: z = 0
   sum(z) -{ 4 }-> s4 :|: s4 >= 0, s4 <= z - 1 + 0, z - 1 >= 0
   sum(z) -{ 2 }-> plus(x, plus(x'', sum(l'))) :|: x >= 0, l' >= 0, x'' >= 0, z = 1 + x + (1 + x'' + l')
   sum(z) -{ 1 }-> 0 :|: z = 0
   times(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 4 + z }-> 1 + s' :|: s' >= 0, s' <= 0 + (z - 1), z - 1 >= 0, z' = 1 + 0
   times(z, z') -{ 5 }-> 1 + s'' :|: s'' >= 0, s'' <= 0 + 0, z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 4 + z' }-> 1 + s1 :|: s1 >= 0, s1 <= 0 + (z' - 1), z = 1 + 0, z' - 1 >= 0
   times(z, z') -{ 42 + s2 + s3 + -14*z + 4*z*z' + 2*z^2 + -5*z' }-> 1 + s7 :|: s5 >= 0, s5 <= 5 * (z - 2) + (z' - 2) + 2 * ((z' - 2) * (z - 2)) + 2 * ((z - 2) * (z - 2)) + 3, s6 >= 0, s6 <= s5 + s2, s7 >= 0, s7 <= 1 + s6 + (1 + (1 + s3)), s2 >= 0, s2 <= z - 2 + (z' - 2), s3 >= 0, s3 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0

Function symbols to be analyzed: {prod}
Previous analysis results are:
  plus: runtime: O(n^1) [2 + z'], size: O(n^1) [z + z']
  times: runtime: O(n^2) [15 + 2*z + 4*z*z' + 2*z^2 + z'], size: O(n^2) [3 + 5*z + 2*z*z' + 2*z^2 + z']
  sum: runtime: O(n^2) [6 + 4*z + 2*z^2], size: O(n^1) [z]

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

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

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

   plus(z, z') -{ 1 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 2 + z' }-> 1 + (1 + s) :|: s >= 0, s <= z - 1 + (z' - 1), z - 1 >= 0, z' - 1 >= 0
   prod(z) -{ 14 + 2*z + 2*z^2 }-> s8 :|: s8 >= 0, s8 <= 5 * (z - 1) + (1 + 0) + 2 * ((1 + 0) * (z - 1)) + 2 * ((z - 1) * (z - 1)) + 3, z - 1 >= 0
   prod(z) -{ 2 }-> times(x, times(x1, prod(l''))) :|: z = 1 + x + (1 + x1 + l''), x1 >= 0, l'' >= 0, x >= 0
   prod(z) -{ 1 }-> 1 + 0 :|: z = 0
   sum(z) -{ 12 + 4*l' + 2*l'^2 + s10 + s9 }-> s11 :|: s9 >= 0, s9 <= l', s10 >= 0, s10 <= x'' + s9, s11 >= 0, s11 <= x + s10, x >= 0, l' >= 0, x'' >= 0, z = 1 + x + (1 + x'' + l')
   sum(z) -{ 4 }-> s4 :|: s4 >= 0, s4 <= z - 1 + 0, z - 1 >= 0
   sum(z) -{ 1 }-> 0 :|: z = 0
   times(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 4 + z }-> 1 + s' :|: s' >= 0, s' <= 0 + (z - 1), z - 1 >= 0, z' = 1 + 0
   times(z, z') -{ 5 }-> 1 + s'' :|: s'' >= 0, s'' <= 0 + 0, z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 4 + z' }-> 1 + s1 :|: s1 >= 0, s1 <= 0 + (z' - 1), z = 1 + 0, z' - 1 >= 0
   times(z, z') -{ 42 + s2 + s3 + -14*z + 4*z*z' + 2*z^2 + -5*z' }-> 1 + s7 :|: s5 >= 0, s5 <= 5 * (z - 2) + (z' - 2) + 2 * ((z' - 2) * (z - 2)) + 2 * ((z - 2) * (z - 2)) + 3, s6 >= 0, s6 <= s5 + s2, s7 >= 0, s7 <= 1 + s6 + (1 + (1 + s3)), s2 >= 0, s2 <= z - 2 + (z' - 2), s3 >= 0, s3 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0

Function symbols to be analyzed: {prod}
Previous analysis results are:
  plus: runtime: O(n^1) [2 + z'], size: O(n^1) [z + z']
  times: runtime: O(n^2) [15 + 2*z + 4*z*z' + 2*z^2 + z'], size: O(n^2) [3 + 5*z + 2*z*z' + 2*z^2 + z']
  sum: runtime: O(n^2) [6 + 4*z + 2*z^2], size: O(n^1) [z]

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

(211) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   plus(z, z') -{ 1 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 2 + z' }-> 1 + (1 + s) :|: s >= 0, s <= z - 1 + (z' - 1), z - 1 >= 0, z' - 1 >= 0
   prod(z) -{ 14 + 2*z + 2*z^2 }-> s8 :|: s8 >= 0, s8 <= 5 * (z - 1) + (1 + 0) + 2 * ((1 + 0) * (z - 1)) + 2 * ((z - 1) * (z - 1)) + 3, z - 1 >= 0
   prod(z) -{ 2 }-> times(x, times(x1, prod(l''))) :|: z = 1 + x + (1 + x1 + l''), x1 >= 0, l'' >= 0, x >= 0
   prod(z) -{ 1 }-> 1 + 0 :|: z = 0
   sum(z) -{ 12 + 4*l' + 2*l'^2 + s10 + s9 }-> s11 :|: s9 >= 0, s9 <= l', s10 >= 0, s10 <= x'' + s9, s11 >= 0, s11 <= x + s10, x >= 0, l' >= 0, x'' >= 0, z = 1 + x + (1 + x'' + l')
   sum(z) -{ 4 }-> s4 :|: s4 >= 0, s4 <= z - 1 + 0, z - 1 >= 0
   sum(z) -{ 1 }-> 0 :|: z = 0
   times(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 4 + z }-> 1 + s' :|: s' >= 0, s' <= 0 + (z - 1), z - 1 >= 0, z' = 1 + 0
   times(z, z') -{ 5 }-> 1 + s'' :|: s'' >= 0, s'' <= 0 + 0, z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 4 + z' }-> 1 + s1 :|: s1 >= 0, s1 <= 0 + (z' - 1), z = 1 + 0, z' - 1 >= 0
   times(z, z') -{ 42 + s2 + s3 + -14*z + 4*z*z' + 2*z^2 + -5*z' }-> 1 + s7 :|: s5 >= 0, s5 <= 5 * (z - 2) + (z' - 2) + 2 * ((z' - 2) * (z - 2)) + 2 * ((z - 2) * (z - 2)) + 3, s6 >= 0, s6 <= s5 + s2, s7 >= 0, s7 <= 1 + s6 + (1 + (1 + s3)), s2 >= 0, s2 <= z - 2 + (z' - 2), s3 >= 0, s3 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0

Function symbols to be analyzed: {prod}
Previous analysis results are:
  plus: runtime: O(n^1) [2 + z'], size: O(n^1) [z + z']
  times: runtime: O(n^2) [15 + 2*z + 4*z*z' + 2*z^2 + z'], size: O(n^2) [3 + 5*z + 2*z*z' + 2*z^2 + z']
  sum: runtime: O(n^2) [6 + 4*z + 2*z^2], size: O(n^1) [z]
  prod: runtime: ?, size: INF

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

(213) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   plus(z, z') -{ 1 }-> z :|: z >= 0, z' = 0
   plus(z, z') -{ 1 }-> z' :|: z' >= 0, z = 0
   plus(z, z') -{ 2 + z' }-> 1 + (1 + s) :|: s >= 0, s <= z - 1 + (z' - 1), z - 1 >= 0, z' - 1 >= 0
   prod(z) -{ 14 + 2*z + 2*z^2 }-> s8 :|: s8 >= 0, s8 <= 5 * (z - 1) + (1 + 0) + 2 * ((1 + 0) * (z - 1)) + 2 * ((z - 1) * (z - 1)) + 3, z - 1 >= 0
   prod(z) -{ 2 }-> times(x, times(x1, prod(l''))) :|: z = 1 + x + (1 + x1 + l''), x1 >= 0, l'' >= 0, x >= 0
   prod(z) -{ 1 }-> 1 + 0 :|: z = 0
   sum(z) -{ 12 + 4*l' + 2*l'^2 + s10 + s9 }-> s11 :|: s9 >= 0, s9 <= l', s10 >= 0, s10 <= x'' + s9, s11 >= 0, s11 <= x + s10, x >= 0, l' >= 0, x'' >= 0, z = 1 + x + (1 + x'' + l')
   sum(z) -{ 4 }-> s4 :|: s4 >= 0, s4 <= z - 1 + 0, z - 1 >= 0
   sum(z) -{ 1 }-> 0 :|: z = 0
   times(z, z') -{ 1 }-> 0 :|: z >= 0, z' = 0
   times(z, z') -{ 1 }-> 0 :|: z' >= 0, z = 0
   times(z, z') -{ 4 + z }-> 1 + s' :|: s' >= 0, s' <= 0 + (z - 1), z - 1 >= 0, z' = 1 + 0
   times(z, z') -{ 5 }-> 1 + s'' :|: s'' >= 0, s'' <= 0 + 0, z = 1 + 0, z' = 1 + 0
   times(z, z') -{ 4 + z' }-> 1 + s1 :|: s1 >= 0, s1 <= 0 + (z' - 1), z = 1 + 0, z' - 1 >= 0
   times(z, z') -{ 42 + s2 + s3 + -14*z + 4*z*z' + 2*z^2 + -5*z' }-> 1 + s7 :|: s5 >= 0, s5 <= 5 * (z - 2) + (z' - 2) + 2 * ((z' - 2) * (z - 2)) + 2 * ((z - 2) * (z - 2)) + 3, s6 >= 0, s6 <= s5 + s2, s7 >= 0, s7 <= 1 + s6 + (1 + (1 + s3)), s2 >= 0, s2 <= z - 2 + (z' - 2), s3 >= 0, s3 <= z - 2 + (z' - 2), z - 2 >= 0, z' - 2 >= 0

Function symbols to be analyzed: {prod}
Previous analysis results are:
  plus: runtime: O(n^1) [2 + z'], size: O(n^1) [z + z']
  times: runtime: O(n^2) [15 + 2*z + 4*z*z' + 2*z^2 + z'], size: O(n^2) [3 + 5*z + 2*z*z' + 2*z^2 + z']
  sum: runtime: O(n^2) [6 + 4*z + 2*z^2], size: O(n^1) [z]
  prod: runtime: INF, size: INF

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

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

And the following fresh constants: none

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

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

   plus(x, 0) -> x [1]
   plus(0, x) -> x [1]
   plus(s(x), s(y)) -> s(s(plus(x, y))) [1]
   times(x, 0) -> 0 [1]
   times(0, x) -> 0 [1]
   times(s(x), s(y)) -> s(plus(times(x, y), plus(x, y))) [1]
   sum(nil) -> 0 [1]
   sum(cons(x, l)) -> plus(x, sum(l)) [1]
   prod(nil) -> s(0) [1]
   prod(cons(x, l)) -> times(x, prod(l)) [1]

The TRS has the following type information:
plus :: 0:s -> 0:s -> 0:s
0 :: 0:s
s :: 0:s -> 0:s
times :: 0:s -> 0:s -> 0:s
sum :: nil:cons -> 0:s
nil :: nil:cons
cons :: 0:s -> nil:cons -> nil:cons
prod :: nil:cons -> 0:s

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

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

   0 => 0
   nil => 0

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

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

   plus(z, z') -{ 1 }-> x :|: x >= 0, z = x, z' = 0
   plus(z, z') -{ 1 }-> x :|: z' = x, x >= 0, z = 0
   plus(z, z') -{ 1 }-> 1 + (1 + plus(x, y)) :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x
   prod(z) -{ 1 }-> times(x, prod(l)) :|: x >= 0, l >= 0, z = 1 + x + l
   prod(z) -{ 1 }-> 1 + 0 :|: z = 0
   sum(z) -{ 1 }-> plus(x, sum(l)) :|: x >= 0, l >= 0, z = 1 + x + l
   sum(z) -{ 1 }-> 0 :|: z = 0
   times(z, z') -{ 1 }-> 0 :|: x >= 0, z = x, z' = 0
   times(z, z') -{ 1 }-> 0 :|: z' = x, x >= 0, z = 0
   times(z, z') -{ 1 }-> 1 + plus(times(x, y), plus(x, y)) :|: z' = 1 + y, x >= 0, y >= 0, z = 1 + x

Only complete derivations are relevant for the runtime complexity.