/export/starexec/sandbox2/solver/bin/starexec_run_complexity /export/starexec/sandbox2/benchmark/theBenchmark.xml /export/starexec/sandbox2/output/output_files


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


WORST_CASE(Omega(n^1), O(n^2))
proof of /export/starexec/sandbox2/benchmark/theBenchmark.xml
# AProVE Commit ID: 48fb2092695e11cc9f56e44b17a92a5f88ffb256 marcel 20180622 unpublished dirty


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

(0) CpxRelTRS
(1) STerminationProof [BOTH CONCRETE BOUNDS(ID, ID), 353 ms]
(2) CpxRelTRS
(3) RelTrsToWeightedTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
(4) CpxWeightedTrs
    (5) CpxWeightedTrsRenamingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (6) CpxWeightedTrs
    (7) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
    (8) CpxTypedWeightedTrs
    (9) CompletionProof [UPPER BOUND(ID), 0 ms]
    (10) CpxTypedWeightedCompleteTrs
    (11) NarrowingProof [BOTH BOUNDS(ID, ID), 3 ms]
    (12) CpxTypedWeightedCompleteTrs
    (13) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
    (14) CpxRNTS
    (15) InliningProof [UPPER BOUND(ID), 965 ms]
    (16) CpxRNTS
    (17) SimplificationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (18) CpxRNTS
    (19) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 2 ms]
    (20) CpxRNTS
    (21) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (22) CpxRNTS
    (23) IntTrsBoundProof [UPPER BOUND(ID), 268 ms]
    (24) CpxRNTS
    (25) IntTrsBoundProof [UPPER BOUND(ID), 55 ms]
    (26) CpxRNTS
    (27) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (28) CpxRNTS
    (29) IntTrsBoundProof [UPPER BOUND(ID), 232 ms]
    (30) CpxRNTS
    (31) IntTrsBoundProof [UPPER BOUND(ID), 33 ms]
    (32) CpxRNTS
    (33) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (34) CpxRNTS
    (35) IntTrsBoundProof [UPPER BOUND(ID), 2399 ms]
    (36) CpxRNTS
    (37) IntTrsBoundProof [UPPER BOUND(ID), 347 ms]
    (38) CpxRNTS
    (39) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (40) CpxRNTS
    (41) IntTrsBoundProof [UPPER BOUND(ID), 683 ms]
    (42) CpxRNTS
    (43) IntTrsBoundProof [UPPER BOUND(ID), 125 ms]
    (44) CpxRNTS
    (45) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (46) CpxRNTS
    (47) IntTrsBoundProof [UPPER BOUND(ID), 1140 ms]
    (48) CpxRNTS
    (49) IntTrsBoundProof [UPPER BOUND(ID), 63 ms]
    (50) CpxRNTS
    (51) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (52) CpxRNTS
    (53) IntTrsBoundProof [UPPER BOUND(ID), 798 ms]
    (54) CpxRNTS
    (55) IntTrsBoundProof [UPPER BOUND(ID), 52 ms]
    (56) CpxRNTS
    (57) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (58) CpxRNTS
    (59) IntTrsBoundProof [UPPER BOUND(ID), 1798 ms]
    (60) CpxRNTS
    (61) IntTrsBoundProof [UPPER BOUND(ID), 158 ms]
    (62) CpxRNTS
    (63) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (64) CpxRNTS
    (65) IntTrsBoundProof [UPPER BOUND(ID), 2006 ms]
    (66) CpxRNTS
    (67) IntTrsBoundProof [UPPER BOUND(ID), 148 ms]
    (68) CpxRNTS
    (69) FinalProof [FINISHED, 0 ms]
    (70) BOUNDS(1, n^2)
(71) RelTrsToDecreasingLoopProblemProof [LOWER BOUND(ID), 0 ms]
(72) TRS for Loop Detection
    (73) DecreasingLoopProof [LOWER BOUND(ID), 33 ms]
    (74) BEST
        (75) proven lower bound
            (76) LowerBoundPropagationProof [FINISHED, 0 ms]
            (77) BOUNDS(n^1, INF)
        (78) TRS for Loop Detection


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

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


The TRS R consists of the following rules:

   *(@x, @y) -> #mult(@x, @y)
   dyade(@l1, @l2) -> dyade#1(@l1, @l2)
   dyade#1(::(@x, @xs), @l2) -> ::(mult(@x, @l2), dyade(@xs, @l2))
   dyade#1(nil, @l2) -> nil
   mult(@n, @l) -> mult#1(@l, @n)
   mult#1(::(@x, @xs), @n) -> ::(*(@n, @x), mult(@n, @xs))
   mult#1(nil, @n) -> nil

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

   #add(#0, @y) -> @y
   #add(#neg(#s(#0)), @y) -> #pred(@y)
   #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
   #add(#pos(#s(#0)), @y) -> #succ(@y)
   #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
   #mult(#0, #0) -> #0
   #mult(#0, #neg(@y)) -> #0
   #mult(#0, #pos(@y)) -> #0
   #mult(#neg(@x), #0) -> #0
   #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
   #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
   #mult(#pos(@x), #0) -> #0
   #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
   #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
   #natmult(#0, @y) -> #0
   #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y))
   #pred(#0) -> #neg(#s(#0))
   #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
   #pred(#pos(#s(#0))) -> #0
   #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
   #succ(#0) -> #pos(#s(#0))
   #succ(#neg(#s(#0))) -> #0
   #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
   #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))

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

(1) STerminationProof (BOTH CONCRETE BOUNDS(ID, ID))
proved termination of relative rules
----------------------------------------

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


The TRS R consists of the following rules:

   *(@x, @y) -> #mult(@x, @y)
   dyade(@l1, @l2) -> dyade#1(@l1, @l2)
   dyade#1(::(@x, @xs), @l2) -> ::(mult(@x, @l2), dyade(@xs, @l2))
   dyade#1(nil, @l2) -> nil
   mult(@n, @l) -> mult#1(@l, @n)
   mult#1(::(@x, @xs), @n) -> ::(*(@n, @x), mult(@n, @xs))
   mult#1(nil, @n) -> nil

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

   #add(#0, @y) -> @y
   #add(#neg(#s(#0)), @y) -> #pred(@y)
   #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
   #add(#pos(#s(#0)), @y) -> #succ(@y)
   #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
   #mult(#0, #0) -> #0
   #mult(#0, #neg(@y)) -> #0
   #mult(#0, #pos(@y)) -> #0
   #mult(#neg(@x), #0) -> #0
   #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
   #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
   #mult(#pos(@x), #0) -> #0
   #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
   #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
   #natmult(#0, @y) -> #0
   #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y))
   #pred(#0) -> #neg(#s(#0))
   #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
   #pred(#pos(#s(#0))) -> #0
   #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
   #succ(#0) -> #pos(#s(#0))
   #succ(#neg(#s(#0))) -> #0
   #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
   #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))

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

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

(4)
Obligation:
The Runtime Complexity (innermost) of the given CpxWeightedTrs could be proven to be BOUNDS(1, n^2).


The TRS R consists of the following rules:

   *(@x, @y) -> #mult(@x, @y) [1]
   dyade(@l1, @l2) -> dyade#1(@l1, @l2) [1]
   dyade#1(::(@x, @xs), @l2) -> ::(mult(@x, @l2), dyade(@xs, @l2)) [1]
   dyade#1(nil, @l2) -> nil [1]
   mult(@n, @l) -> mult#1(@l, @n) [1]
   mult#1(::(@x, @xs), @n) -> ::(*(@n, @x), mult(@n, @xs)) [1]
   mult#1(nil, @n) -> nil [1]
   #add(#0, @y) -> @y [0]
   #add(#neg(#s(#0)), @y) -> #pred(@y) [0]
   #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) [0]
   #add(#pos(#s(#0)), @y) -> #succ(@y) [0]
   #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) [0]
   #mult(#0, #0) -> #0 [0]
   #mult(#0, #neg(@y)) -> #0 [0]
   #mult(#0, #pos(@y)) -> #0 [0]
   #mult(#neg(@x), #0) -> #0 [0]
   #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) [0]
   #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) [0]
   #mult(#pos(@x), #0) -> #0 [0]
   #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) [0]
   #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) [0]
   #natmult(#0, @y) -> #0 [0]
   #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) [0]
   #pred(#0) -> #neg(#s(#0)) [0]
   #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) [0]
   #pred(#pos(#s(#0))) -> #0 [0]
   #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) [0]
   #succ(#0) -> #pos(#s(#0)) [0]
   #succ(#neg(#s(#0))) -> #0 [0]
   #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) [0]
   #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) [0]

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

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

* => times

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

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


The TRS R consists of the following rules:

   times(@x, @y) -> #mult(@x, @y) [1]
   dyade(@l1, @l2) -> dyade#1(@l1, @l2) [1]
   dyade#1(::(@x, @xs), @l2) -> ::(mult(@x, @l2), dyade(@xs, @l2)) [1]
   dyade#1(nil, @l2) -> nil [1]
   mult(@n, @l) -> mult#1(@l, @n) [1]
   mult#1(::(@x, @xs), @n) -> ::(times(@n, @x), mult(@n, @xs)) [1]
   mult#1(nil, @n) -> nil [1]
   #add(#0, @y) -> @y [0]
   #add(#neg(#s(#0)), @y) -> #pred(@y) [0]
   #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) [0]
   #add(#pos(#s(#0)), @y) -> #succ(@y) [0]
   #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) [0]
   #mult(#0, #0) -> #0 [0]
   #mult(#0, #neg(@y)) -> #0 [0]
   #mult(#0, #pos(@y)) -> #0 [0]
   #mult(#neg(@x), #0) -> #0 [0]
   #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) [0]
   #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) [0]
   #mult(#pos(@x), #0) -> #0 [0]
   #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) [0]
   #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) [0]
   #natmult(#0, @y) -> #0 [0]
   #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) [0]
   #pred(#0) -> #neg(#s(#0)) [0]
   #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) [0]
   #pred(#pos(#s(#0))) -> #0 [0]
   #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) [0]
   #succ(#0) -> #pos(#s(#0)) [0]
   #succ(#neg(#s(#0))) -> #0 [0]
   #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) [0]
   #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) [0]

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

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

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

   times(@x, @y) -> #mult(@x, @y) [1]
   dyade(@l1, @l2) -> dyade#1(@l1, @l2) [1]
   dyade#1(::(@x, @xs), @l2) -> ::(mult(@x, @l2), dyade(@xs, @l2)) [1]
   dyade#1(nil, @l2) -> nil [1]
   mult(@n, @l) -> mult#1(@l, @n) [1]
   mult#1(::(@x, @xs), @n) -> ::(times(@n, @x), mult(@n, @xs)) [1]
   mult#1(nil, @n) -> nil [1]
   #add(#0, @y) -> @y [0]
   #add(#neg(#s(#0)), @y) -> #pred(@y) [0]
   #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) [0]
   #add(#pos(#s(#0)), @y) -> #succ(@y) [0]
   #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) [0]
   #mult(#0, #0) -> #0 [0]
   #mult(#0, #neg(@y)) -> #0 [0]
   #mult(#0, #pos(@y)) -> #0 [0]
   #mult(#neg(@x), #0) -> #0 [0]
   #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) [0]
   #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) [0]
   #mult(#pos(@x), #0) -> #0 [0]
   #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) [0]
   #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) [0]
   #natmult(#0, @y) -> #0 [0]
   #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) [0]
   #pred(#0) -> #neg(#s(#0)) [0]
   #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) [0]
   #pred(#pos(#s(#0))) -> #0 [0]
   #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) [0]
   #succ(#0) -> #pos(#s(#0)) [0]
   #succ(#neg(#s(#0))) -> #0 [0]
   #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) [0]
   #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) [0]

The TRS has the following type information:
times :: :::nil:#0:#s:#neg:#pos -> :::nil:#0:#s:#neg:#pos -> :::nil:#0:#s:#neg:#pos
#mult :: :::nil:#0:#s:#neg:#pos -> :::nil:#0:#s:#neg:#pos -> :::nil:#0:#s:#neg:#pos
dyade :: :::nil:#0:#s:#neg:#pos -> :::nil:#0:#s:#neg:#pos -> :::nil:#0:#s:#neg:#pos
dyade#1 :: :::nil:#0:#s:#neg:#pos -> :::nil:#0:#s:#neg:#pos -> :::nil:#0:#s:#neg:#pos
:: :: :::nil:#0:#s:#neg:#pos -> :::nil:#0:#s:#neg:#pos -> :::nil:#0:#s:#neg:#pos
mult :: :::nil:#0:#s:#neg:#pos -> :::nil:#0:#s:#neg:#pos -> :::nil:#0:#s:#neg:#pos
nil :: :::nil:#0:#s:#neg:#pos
mult#1 :: :::nil:#0:#s:#neg:#pos -> :::nil:#0:#s:#neg:#pos -> :::nil:#0:#s:#neg:#pos
#add :: :::nil:#0:#s:#neg:#pos -> :::nil:#0:#s:#neg:#pos -> :::nil:#0:#s:#neg:#pos
#0 :: :::nil:#0:#s:#neg:#pos
#neg :: :::nil:#0:#s:#neg:#pos -> :::nil:#0:#s:#neg:#pos
#s :: :::nil:#0:#s:#neg:#pos -> :::nil:#0:#s:#neg:#pos
#pred :: :::nil:#0:#s:#neg:#pos -> :::nil:#0:#s:#neg:#pos
#pos :: :::nil:#0:#s:#neg:#pos -> :::nil:#0:#s:#neg:#pos
#succ :: :::nil:#0:#s:#neg:#pos -> :::nil:#0:#s:#neg:#pos
#natmult :: :::nil:#0:#s:#neg:#pos -> :::nil:#0:#s:#neg:#pos -> :::nil:#0:#s:#neg:#pos

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

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

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

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

   times_2
   dyade_2
   dyade#1_2
   mult_2
   mult#1_2

(c) The following functions are completely defined:

   #add_2
   #mult_2
   #natmult_2
   #pred_1
   #succ_1

Due to the following rules being added:

   #add(v0, v1) -> null_#add [0]
   #mult(v0, v1) -> null_#mult [0]
   #natmult(v0, v1) -> null_#natmult [0]
   #pred(v0) -> null_#pred [0]
   #succ(v0) -> null_#succ [0]

And the following fresh constants:    null_#add, null_#mult, null_#natmult, null_#pred, null_#succ

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

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

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

   times(@x, @y) -> #mult(@x, @y) [1]
   dyade(@l1, @l2) -> dyade#1(@l1, @l2) [1]
   dyade#1(::(@x, @xs), @l2) -> ::(mult(@x, @l2), dyade(@xs, @l2)) [1]
   dyade#1(nil, @l2) -> nil [1]
   mult(@n, @l) -> mult#1(@l, @n) [1]
   mult#1(::(@x, @xs), @n) -> ::(times(@n, @x), mult(@n, @xs)) [1]
   mult#1(nil, @n) -> nil [1]
   #add(#0, @y) -> @y [0]
   #add(#neg(#s(#0)), @y) -> #pred(@y) [0]
   #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y)) [0]
   #add(#pos(#s(#0)), @y) -> #succ(@y) [0]
   #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y)) [0]
   #mult(#0, #0) -> #0 [0]
   #mult(#0, #neg(@y)) -> #0 [0]
   #mult(#0, #pos(@y)) -> #0 [0]
   #mult(#neg(@x), #0) -> #0 [0]
   #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) [0]
   #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) [0]
   #mult(#pos(@x), #0) -> #0 [0]
   #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) [0]
   #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) [0]
   #natmult(#0, @y) -> #0 [0]
   #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y)) [0]
   #pred(#0) -> #neg(#s(#0)) [0]
   #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) [0]
   #pred(#pos(#s(#0))) -> #0 [0]
   #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) [0]
   #succ(#0) -> #pos(#s(#0)) [0]
   #succ(#neg(#s(#0))) -> #0 [0]
   #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) [0]
   #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) [0]
   #add(v0, v1) -> null_#add [0]
   #mult(v0, v1) -> null_#mult [0]
   #natmult(v0, v1) -> null_#natmult [0]
   #pred(v0) -> null_#pred [0]
   #succ(v0) -> null_#succ [0]

The TRS has the following type information:
times :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
#mult :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
dyade :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
dyade#1 :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
:: :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
mult :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
nil :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
mult#1 :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
#add :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
#0 :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
#neg :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
#s :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
#pred :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
#pos :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
#succ :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
#natmult :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
null_#add :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
null_#mult :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
null_#natmult :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
null_#pred :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
null_#succ :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ

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

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

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

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

   times(@x, @y) -> #mult(@x, @y) [1]
   dyade(@l1, @l2) -> dyade#1(@l1, @l2) [1]
   dyade#1(::(@x, @xs), @l2) -> ::(mult(@x, @l2), dyade(@xs, @l2)) [1]
   dyade#1(nil, @l2) -> nil [1]
   mult(@n, @l) -> mult#1(@l, @n) [1]
   mult#1(::(@x, @xs), @n) -> ::(times(@n, @x), mult(@n, @xs)) [1]
   mult#1(nil, @n) -> nil [1]
   #add(#0, @y) -> @y [0]
   #add(#neg(#s(#0)), @y) -> #pred(@y) [0]
   #add(#neg(#s(#s(#0))), @y) -> #pred(#succ(@y)) [0]
   #add(#neg(#s(#s(#s(@x')))), @y) -> #pred(#succ(#add(#pos(#s(@x')), @y))) [0]
   #add(#neg(#s(#s(@x))), @y) -> #pred(null_#add) [0]
   #add(#pos(#s(#0)), @y) -> #succ(@y) [0]
   #add(#pos(#s(#s(#0))), @y) -> #succ(#succ(@y)) [0]
   #add(#pos(#s(#s(#s(@x'')))), @y) -> #succ(#succ(#add(#pos(#s(@x'')), @y))) [0]
   #add(#pos(#s(#s(@x))), @y) -> #succ(null_#add) [0]
   #mult(#0, #0) -> #0 [0]
   #mult(#0, #neg(@y)) -> #0 [0]
   #mult(#0, #pos(@y)) -> #0 [0]
   #mult(#neg(@x), #0) -> #0 [0]
   #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y)) [0]
   #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y)) [0]
   #mult(#pos(@x), #0) -> #0 [0]
   #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y)) [0]
   #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y)) [0]
   #natmult(#0, @y) -> #0 [0]
   #natmult(#s(#0), @y) -> #add(#pos(@y), #0) [0]
   #natmult(#s(#s(@x1)), @y) -> #add(#pos(@y), #add(#pos(@y), #natmult(@x1, @y))) [0]
   #natmult(#s(@x), @y) -> #add(#pos(@y), null_#natmult) [0]
   #pred(#0) -> #neg(#s(#0)) [0]
   #pred(#neg(#s(@x))) -> #neg(#s(#s(@x))) [0]
   #pred(#pos(#s(#0))) -> #0 [0]
   #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x)) [0]
   #succ(#0) -> #pos(#s(#0)) [0]
   #succ(#neg(#s(#0))) -> #0 [0]
   #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x)) [0]
   #succ(#pos(#s(@x))) -> #pos(#s(#s(@x))) [0]
   #add(v0, v1) -> null_#add [0]
   #mult(v0, v1) -> null_#mult [0]
   #natmult(v0, v1) -> null_#natmult [0]
   #pred(v0) -> null_#pred [0]
   #succ(v0) -> null_#succ [0]

The TRS has the following type information:
times :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
#mult :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
dyade :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
dyade#1 :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
:: :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
mult :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
nil :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
mult#1 :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
#add :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
#0 :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
#neg :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
#s :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
#pred :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
#pos :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
#succ :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
#natmult :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ -> :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
null_#add :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
null_#mult :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
null_#natmult :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
null_#pred :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ
null_#succ :: :::nil:#0:#s:#neg:#pos:null_#add:null_#mult:null_#natmult:null_#pred:null_#succ

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

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

   nil => 1
   #0 => 0
   null_#add => 0
   null_#mult => 0
   null_#natmult => 0
   null_#pred => 0
   null_#succ => 0

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

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

   #add(z, z') -{ 0 }-> @y :|: z' = @y, z = 0, @y >= 0
   #add(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   #add(z, z') -{ 0 }-> #succ(@y) :|: z = 1 + (1 + 0), z' = @y, @y >= 0
   #add(z, z') -{ 0 }-> #succ(0) :|: @x >= 0, z' = @y, z = 1 + (1 + (1 + @x)), @y >= 0
   #add(z, z') -{ 0 }-> #succ(#succ(@y)) :|: z' = @y, z = 1 + (1 + (1 + 0)), @y >= 0
   #add(z, z') -{ 0 }-> #succ(#succ(#add(1 + (1 + @x''), @y))) :|: z = 1 + (1 + (1 + (1 + @x''))), z' = @y, @x'' >= 0, @y >= 0
   #add(z, z') -{ 0 }-> #pred(@y) :|: z = 1 + (1 + 0), z' = @y, @y >= 0
   #add(z, z') -{ 0 }-> #pred(0) :|: @x >= 0, z' = @y, z = 1 + (1 + (1 + @x)), @y >= 0
   #add(z, z') -{ 0 }-> #pred(#succ(@y)) :|: z' = @y, z = 1 + (1 + (1 + 0)), @y >= 0
   #add(z, z') -{ 0 }-> #pred(#succ(#add(1 + (1 + @x'), @y))) :|: z = 1 + (1 + (1 + (1 + @x'))), z' = @y, @y >= 0, @x' >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' = 1 + @y, @y >= 0
   #mult(z, z') -{ 0 }-> 0 :|: @x >= 0, z = 1 + @x, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   #mult(z, z') -{ 0 }-> 1 + #natmult(@x, @y) :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z' = @y, z = 0, @y >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   #natmult(z, z') -{ 0 }-> #add(1 + @y, 0) :|: z = 1 + 0, z' = @y, @y >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + @y, 0) :|: @x >= 0, z = 1 + @x, z' = @y, @y >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + @y, #add(1 + @y, #natmult(@x1, @y))) :|: @x1 >= 0, z' = @y, z = 1 + (1 + @x1), @y >= 0
   #pred(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #pred(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   #pred(z) -{ 0 }-> 1 + (1 + @x) :|: @x >= 0, z = 1 + (1 + (1 + @x))
   #pred(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #pred(z) -{ 0 }-> 1 + (1 + (1 + @x)) :|: @x >= 0, z = 1 + (1 + @x)
   #succ(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #succ(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   #succ(z) -{ 0 }-> 1 + (1 + @x) :|: @x >= 0, z = 1 + (1 + (1 + @x))
   #succ(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #succ(z) -{ 0 }-> 1 + (1 + (1 + @x)) :|: @x >= 0, z = 1 + (1 + @x)
   dyade(z, z') -{ 1 }-> dyade#1(@l1, @l2) :|: @l1 >= 0, z' = @l2, @l2 >= 0, z = @l1
   dyade#1(z, z') -{ 1 }-> 1 :|: z' = @l2, z = 1, @l2 >= 0
   dyade#1(z, z') -{ 1 }-> 1 + mult(@x, @l2) + dyade(@xs, @l2) :|: z' = @l2, @x >= 0, z = 1 + @x + @xs, @l2 >= 0, @xs >= 0
   mult(z, z') -{ 1 }-> mult#1(@l, @n) :|: @l >= 0, @n >= 0, z' = @l, z = @n
   mult#1(z, z') -{ 1 }-> 1 :|: z' = @n, z = 1, @n >= 0
   mult#1(z, z') -{ 1 }-> 1 + times(@n, @x) + mult(@n, @xs) :|: z' = @n, @x >= 0, z = 1 + @x + @xs, @n >= 0, @xs >= 0
   times(z, z') -{ 1 }-> #mult(@x, @y) :|: z = @x, @x >= 0, z' = @y, @y >= 0


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

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

   #pred(z) -{ 0 }-> 1 + (1 + (1 + @x)) :|: @x >= 0, z = 1 + (1 + @x)
   #pred(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #pred(z) -{ 0 }-> 1 + (1 + @x) :|: @x >= 0, z = 1 + (1 + (1 + @x))
   #pred(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #pred(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   #succ(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   #succ(z) -{ 0 }-> 1 + (1 + @x) :|: @x >= 0, z = 1 + (1 + (1 + @x))
   #succ(z) -{ 0 }-> 1 + (1 + (1 + @x)) :|: @x >= 0, z = 1 + (1 + @x)
   #succ(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #succ(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0

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

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

   #add(z, z') -{ 0 }-> @y :|: z' = @y, z = 0, @y >= 0
   #add(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' = @y, @y >= 0, @y = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' = @y, @y >= 0, v0 >= 0, @y = v0
   #add(z, z') -{ 0 }-> 0 :|: @x >= 0, z' = @y, z = 1 + (1 + (1 + @x)), @y >= 0, v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z' = @y, z = 1 + (1 + (1 + 0)), @y >= 0, v0 >= 0, @y = v0, v0' >= 0, 0 = v0'
   #add(z, z') -{ 0 }-> 0 :|: z' = @y, z = 1 + (1 + (1 + 0)), @y >= 0, @x >= 0, @y = 1 + (1 + (1 + @x)), v0 >= 0, 1 + (1 + @x) = v0
   #add(z, z') -{ 0 }-> 0 :|: z' = @y, z = 1 + (1 + (1 + 0)), @y >= 0, @x >= 0, @y = 1 + (1 + (1 + @x)), 1 + (1 + @x) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z' = @y, z = 1 + (1 + (1 + 0)), @y >= 0, @x >= 0, @y = 1 + (1 + @x), v0 >= 0, 1 + (1 + (1 + @x)) = v0
   #add(z, z') -{ 0 }-> 0 :|: z' = @y, z = 1 + (1 + (1 + 0)), @y >= 0, @y = 1 + (1 + 0), v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z' = @y, z = 1 + (1 + (1 + 0)), @y >= 0, @y = 0, v0 >= 0, 1 + (1 + 0) = v0
   #add(z, z') -{ 0 }-> 0 :|: z' = @y, z = 1 + (1 + (1 + 0)), @y >= 0, @y = 0, 1 + (1 + 0) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 1 + (1 + @x) :|: z = 1 + (1 + 0), z' = @y, @y >= 0, @x >= 0, @y = 1 + (1 + (1 + @x))
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z' = @y, z = 1 + (1 + (1 + 0)), @y >= 0, @x >= 0, @y = 1 + (1 + (1 + @x)), @x' >= 0, 1 + (1 + @x) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z' = @y, z = 1 + (1 + (1 + 0)), @y >= 0, @x >= 0, @y = 1 + (1 + @x), @x' >= 0, 1 + (1 + (1 + @x)) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + 0), z' = @y, @y >= 0, @y = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: @x >= 0, z' = @y, z = 1 + (1 + (1 + @x)), @y >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z' = @y, z = 1 + (1 + (1 + 0)), @y >= 0, v0 >= 0, @y = v0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z' = @y, z = 1 + (1 + (1 + 0)), @y >= 0, @y = 1 + (1 + 0), 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x)) :|: z = 1 + (1 + 0), z' = @y, @y >= 0, @x >= 0, @y = 1 + (1 + @x)
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x)) :|: z' = @y, z = 1 + (1 + (1 + 0)), @y >= 0, @y = 0, @x >= 0, 1 + (1 + 0) = 1 + (1 + @x)
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z' = @y, z = 1 + (1 + (1 + 0)), @y >= 0, @x >= 0, @y = 1 + (1 + (1 + @x)), @x' >= 0, 1 + (1 + @x) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z' = @y, z = 1 + (1 + (1 + 0)), @y >= 0, @x >= 0, @y = 1 + (1 + @x), @x' >= 0, 1 + (1 + (1 + @x)) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> #succ(#succ(#add(1 + (1 + @x''), @y))) :|: z = 1 + (1 + (1 + (1 + @x''))), z' = @y, @x'' >= 0, @y >= 0
   #add(z, z') -{ 0 }-> #pred(0) :|: z' = @y, z = 1 + (1 + (1 + 0)), @y >= 0, v0 >= 0, @y = v0
   #add(z, z') -{ 0 }-> #pred(0) :|: z' = @y, z = 1 + (1 + (1 + 0)), @y >= 0, @y = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> #pred(1 + (1 + @x)) :|: z' = @y, z = 1 + (1 + (1 + 0)), @y >= 0, @x >= 0, @y = 1 + (1 + (1 + @x))
   #add(z, z') -{ 0 }-> #pred(1 + (1 + 0)) :|: z' = @y, z = 1 + (1 + (1 + 0)), @y >= 0, @y = 0
   #add(z, z') -{ 0 }-> #pred(1 + (1 + (1 + @x))) :|: z' = @y, z = 1 + (1 + (1 + 0)), @y >= 0, @x >= 0, @y = 1 + (1 + @x)
   #add(z, z') -{ 0 }-> #pred(#succ(#add(1 + (1 + @x'), @y))) :|: z = 1 + (1 + (1 + (1 + @x'))), z' = @y, @y >= 0, @x' >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' = 1 + @y, @y >= 0
   #mult(z, z') -{ 0 }-> 0 :|: @x >= 0, z = 1 + @x, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   #mult(z, z') -{ 0 }-> 1 + #natmult(@x, @y) :|: @x >= 0, z = 1 + @x, z' = 1 + @y, @y >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z' = @y, z = 0, @y >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   #natmult(z, z') -{ 0 }-> #add(1 + @y, 0) :|: z = 1 + 0, z' = @y, @y >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + @y, 0) :|: @x >= 0, z = 1 + @x, z' = @y, @y >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + @y, #add(1 + @y, #natmult(@x1, @y))) :|: @x1 >= 0, z' = @y, z = 1 + (1 + @x1), @y >= 0
   #pred(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #pred(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   #pred(z) -{ 0 }-> 1 + (1 + @x) :|: @x >= 0, z = 1 + (1 + (1 + @x))
   #pred(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #pred(z) -{ 0 }-> 1 + (1 + (1 + @x)) :|: @x >= 0, z = 1 + (1 + @x)
   #succ(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #succ(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   #succ(z) -{ 0 }-> 1 + (1 + @x) :|: @x >= 0, z = 1 + (1 + (1 + @x))
   #succ(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #succ(z) -{ 0 }-> 1 + (1 + (1 + @x)) :|: @x >= 0, z = 1 + (1 + @x)
   dyade(z, z') -{ 1 }-> dyade#1(@l1, @l2) :|: @l1 >= 0, z' = @l2, @l2 >= 0, z = @l1
   dyade#1(z, z') -{ 1 }-> 1 :|: z' = @l2, z = 1, @l2 >= 0
   dyade#1(z, z') -{ 1 }-> 1 + mult(@x, @l2) + dyade(@xs, @l2) :|: z' = @l2, @x >= 0, z = 1 + @x + @xs, @l2 >= 0, @xs >= 0
   mult(z, z') -{ 1 }-> mult#1(@l, @n) :|: @l >= 0, @n >= 0, z' = @l, z = @n
   mult#1(z, z') -{ 1 }-> 1 :|: z' = @n, z = 1, @n >= 0
   mult#1(z, z') -{ 1 }-> 1 + times(@n, @x) + mult(@n, @xs) :|: z' = @n, @x >= 0, z = 1 + @x + @xs, @n >= 0, @xs >= 0
   times(z, z') -{ 1 }-> #mult(@x, @y) :|: z = @x, @x >= 0, z' = @y, @y >= 0


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

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

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

   #add(z, z') -{ 0 }-> z' :|: z = 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' >= 0, v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, v0' >= 0, 0 = v0'
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, v0 >= 0, 1 + (1 + (z' - 3)) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, v0 >= 0, 1 + (1 + (1 + (z' - 2))) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, v0 >= 0, 1 + (1 + 0) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, 1 + (1 + 0) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + 0), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z - 3 >= 0, z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + (z' - 3)) :|: z = 1 + (1 + 0), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x)) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, @x >= 0, 1 + (1 + 0) = 1 + (1 + @x)
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + (z' - 2))) :|: z = 1 + (1 + 0), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> #succ(#succ(#add(1 + (1 + (z - 4)), z'))) :|: z - 4 >= 0, z' >= 0
   #add(z, z') -{ 0 }-> #pred(0) :|: z = 1 + (1 + (1 + 0)), z' >= 0
   #add(z, z') -{ 0 }-> #pred(0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> #pred(1 + (1 + 0)) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> #pred(1 + (1 + (z' - 3))) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> #pred(1 + (1 + (1 + (z' - 2)))) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> #pred(#succ(#add(1 + (1 + (z - 4)), z'))) :|: z' >= 0, z - 4 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' - 1 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #mult(z, z') -{ 0 }-> 1 + #natmult(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z = 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', 0) :|: z = 1 + 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', 0) :|: z - 1 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', #add(1 + z', #natmult(z - 2, z'))) :|: z - 2 >= 0, z' >= 0
   #pred(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #pred(z) -{ 0 }-> 0 :|: z >= 0
   #pred(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #pred(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #pred(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   #succ(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #succ(z) -{ 0 }-> 0 :|: z >= 0
   #succ(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #succ(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #succ(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   dyade(z, z') -{ 1 }-> dyade#1(z, z') :|: z >= 0, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 + mult(@x, z') + dyade(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   mult(z, z') -{ 1 }-> mult#1(z', z) :|: z' >= 0, z >= 0
   mult#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   mult#1(z, z') -{ 1 }-> 1 + times(z', @x) + mult(z', @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   times(z, z') -{ 1 }-> #mult(z, z') :|: z >= 0, z' >= 0


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

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

   { #pred }
   { #succ }
   { #add }
   { #natmult }
   { #mult }
   { times }
   { mult#1, mult }
   { dyade, dyade#1 }

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

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

   #add(z, z') -{ 0 }-> z' :|: z = 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' >= 0, v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, v0' >= 0, 0 = v0'
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, v0 >= 0, 1 + (1 + (z' - 3)) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, v0 >= 0, 1 + (1 + (1 + (z' - 2))) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, v0 >= 0, 1 + (1 + 0) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, 1 + (1 + 0) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + 0), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z - 3 >= 0, z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + (z' - 3)) :|: z = 1 + (1 + 0), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x)) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, @x >= 0, 1 + (1 + 0) = 1 + (1 + @x)
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + (z' - 2))) :|: z = 1 + (1 + 0), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> #succ(#succ(#add(1 + (1 + (z - 4)), z'))) :|: z - 4 >= 0, z' >= 0
   #add(z, z') -{ 0 }-> #pred(0) :|: z = 1 + (1 + (1 + 0)), z' >= 0
   #add(z, z') -{ 0 }-> #pred(0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> #pred(1 + (1 + 0)) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> #pred(1 + (1 + (z' - 3))) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> #pred(1 + (1 + (1 + (z' - 2)))) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> #pred(#succ(#add(1 + (1 + (z - 4)), z'))) :|: z' >= 0, z - 4 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' - 1 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #mult(z, z') -{ 0 }-> 1 + #natmult(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z = 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', 0) :|: z = 1 + 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', 0) :|: z - 1 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', #add(1 + z', #natmult(z - 2, z'))) :|: z - 2 >= 0, z' >= 0
   #pred(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #pred(z) -{ 0 }-> 0 :|: z >= 0
   #pred(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #pred(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #pred(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   #succ(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #succ(z) -{ 0 }-> 0 :|: z >= 0
   #succ(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #succ(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #succ(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   dyade(z, z') -{ 1 }-> dyade#1(z, z') :|: z >= 0, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 + mult(@x, z') + dyade(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   mult(z, z') -{ 1 }-> mult#1(z', z) :|: z' >= 0, z >= 0
   mult#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   mult#1(z, z') -{ 1 }-> 1 + times(z', @x) + mult(z', @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   times(z, z') -{ 1 }-> #mult(z, z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {#pred}, {#succ}, {#add}, {#natmult}, {#mult}, {times}, {mult#1,mult}, {dyade,dyade#1}

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

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

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

   #add(z, z') -{ 0 }-> z' :|: z = 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' >= 0, v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, v0' >= 0, 0 = v0'
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, v0 >= 0, 1 + (1 + (z' - 3)) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, v0 >= 0, 1 + (1 + (1 + (z' - 2))) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, v0 >= 0, 1 + (1 + 0) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, 1 + (1 + 0) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + 0), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z - 3 >= 0, z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + (z' - 3)) :|: z = 1 + (1 + 0), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x)) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, @x >= 0, 1 + (1 + 0) = 1 + (1 + @x)
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + (z' - 2))) :|: z = 1 + (1 + 0), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> #succ(#succ(#add(1 + (1 + (z - 4)), z'))) :|: z - 4 >= 0, z' >= 0
   #add(z, z') -{ 0 }-> #pred(0) :|: z = 1 + (1 + (1 + 0)), z' >= 0
   #add(z, z') -{ 0 }-> #pred(0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> #pred(1 + (1 + 0)) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> #pred(1 + (1 + (z' - 3))) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> #pred(1 + (1 + (1 + (z' - 2)))) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> #pred(#succ(#add(1 + (1 + (z - 4)), z'))) :|: z' >= 0, z - 4 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' - 1 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #mult(z, z') -{ 0 }-> 1 + #natmult(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z = 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', 0) :|: z = 1 + 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', 0) :|: z - 1 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', #add(1 + z', #natmult(z - 2, z'))) :|: z - 2 >= 0, z' >= 0
   #pred(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #pred(z) -{ 0 }-> 0 :|: z >= 0
   #pred(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #pred(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #pred(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   #succ(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #succ(z) -{ 0 }-> 0 :|: z >= 0
   #succ(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #succ(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #succ(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   dyade(z, z') -{ 1 }-> dyade#1(z, z') :|: z >= 0, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 + mult(@x, z') + dyade(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   mult(z, z') -{ 1 }-> mult#1(z', z) :|: z' >= 0, z >= 0
   mult#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   mult#1(z, z') -{ 1 }-> 1 + times(z', @x) + mult(z', @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   times(z, z') -{ 1 }-> #mult(z, z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {#pred}, {#succ}, {#add}, {#natmult}, {#mult}, {times}, {mult#1,mult}, {dyade,dyade#1}

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

(23) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #add(z, z') -{ 0 }-> z' :|: z = 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' >= 0, v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, v0' >= 0, 0 = v0'
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, v0 >= 0, 1 + (1 + (z' - 3)) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, v0 >= 0, 1 + (1 + (1 + (z' - 2))) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, v0 >= 0, 1 + (1 + 0) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, 1 + (1 + 0) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + 0), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z - 3 >= 0, z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + (z' - 3)) :|: z = 1 + (1 + 0), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x)) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, @x >= 0, 1 + (1 + 0) = 1 + (1 + @x)
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + (z' - 2))) :|: z = 1 + (1 + 0), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> #succ(#succ(#add(1 + (1 + (z - 4)), z'))) :|: z - 4 >= 0, z' >= 0
   #add(z, z') -{ 0 }-> #pred(0) :|: z = 1 + (1 + (1 + 0)), z' >= 0
   #add(z, z') -{ 0 }-> #pred(0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> #pred(1 + (1 + 0)) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> #pred(1 + (1 + (z' - 3))) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> #pred(1 + (1 + (1 + (z' - 2)))) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> #pred(#succ(#add(1 + (1 + (z - 4)), z'))) :|: z' >= 0, z - 4 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' - 1 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #mult(z, z') -{ 0 }-> 1 + #natmult(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z = 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', 0) :|: z = 1 + 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', 0) :|: z - 1 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', #add(1 + z', #natmult(z - 2, z'))) :|: z - 2 >= 0, z' >= 0
   #pred(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #pred(z) -{ 0 }-> 0 :|: z >= 0
   #pred(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #pred(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #pred(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   #succ(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #succ(z) -{ 0 }-> 0 :|: z >= 0
   #succ(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #succ(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #succ(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   dyade(z, z') -{ 1 }-> dyade#1(z, z') :|: z >= 0, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 + mult(@x, z') + dyade(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   mult(z, z') -{ 1 }-> mult#1(z', z) :|: z' >= 0, z >= 0
   mult#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   mult#1(z, z') -{ 1 }-> 1 + times(z', @x) + mult(z', @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   times(z, z') -{ 1 }-> #mult(z, z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {#pred}, {#succ}, {#add}, {#natmult}, {#mult}, {times}, {mult#1,mult}, {dyade,dyade#1}
Previous analysis results are:
  #pred: runtime: ?, size: O(n^1) [2 + z]

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

(25) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #add(z, z') -{ 0 }-> z' :|: z = 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' >= 0, v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, v0' >= 0, 0 = v0'
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, v0 >= 0, 1 + (1 + (z' - 3)) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, v0 >= 0, 1 + (1 + (1 + (z' - 2))) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, v0 >= 0, 1 + (1 + 0) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, 1 + (1 + 0) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + 0), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z - 3 >= 0, z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + (z' - 3)) :|: z = 1 + (1 + 0), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x)) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, @x >= 0, 1 + (1 + 0) = 1 + (1 + @x)
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + (z' - 2))) :|: z = 1 + (1 + 0), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> #succ(#succ(#add(1 + (1 + (z - 4)), z'))) :|: z - 4 >= 0, z' >= 0
   #add(z, z') -{ 0 }-> #pred(0) :|: z = 1 + (1 + (1 + 0)), z' >= 0
   #add(z, z') -{ 0 }-> #pred(0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> #pred(1 + (1 + 0)) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> #pred(1 + (1 + (z' - 3))) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> #pred(1 + (1 + (1 + (z' - 2)))) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> #pred(#succ(#add(1 + (1 + (z - 4)), z'))) :|: z' >= 0, z - 4 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' - 1 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #mult(z, z') -{ 0 }-> 1 + #natmult(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z = 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', 0) :|: z = 1 + 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', 0) :|: z - 1 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', #add(1 + z', #natmult(z - 2, z'))) :|: z - 2 >= 0, z' >= 0
   #pred(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #pred(z) -{ 0 }-> 0 :|: z >= 0
   #pred(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #pred(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #pred(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   #succ(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #succ(z) -{ 0 }-> 0 :|: z >= 0
   #succ(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #succ(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #succ(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   dyade(z, z') -{ 1 }-> dyade#1(z, z') :|: z >= 0, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 + mult(@x, z') + dyade(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   mult(z, z') -{ 1 }-> mult#1(z', z) :|: z' >= 0, z >= 0
   mult#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   mult#1(z, z') -{ 1 }-> 1 + times(z', @x) + mult(z', @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   times(z, z') -{ 1 }-> #mult(z, z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {#succ}, {#add}, {#natmult}, {#mult}, {times}, {mult#1,mult}, {dyade,dyade#1}
Previous analysis results are:
  #pred: runtime: O(1) [0], size: O(n^1) [2 + z]

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

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

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

   #add(z, z') -{ 0 }-> s :|: s >= 0, s <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0
   #add(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 1 + (1 + (z' - 3)) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 1 + (1 + (1 + (z' - 2))) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> s2 :|: s2 >= 0, s2 <= 1 + (1 + 0) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> z' :|: z = 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' >= 0, v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, v0' >= 0, 0 = v0'
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, v0 >= 0, 1 + (1 + (z' - 3)) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, v0 >= 0, 1 + (1 + (1 + (z' - 2))) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, v0 >= 0, 1 + (1 + 0) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, 1 + (1 + 0) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + 0), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z - 3 >= 0, z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + (z' - 3)) :|: z = 1 + (1 + 0), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x)) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, @x >= 0, 1 + (1 + 0) = 1 + (1 + @x)
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + (z' - 2))) :|: z = 1 + (1 + 0), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> #succ(#succ(#add(1 + (1 + (z - 4)), z'))) :|: z - 4 >= 0, z' >= 0
   #add(z, z') -{ 0 }-> #pred(#succ(#add(1 + (1 + (z - 4)), z'))) :|: z' >= 0, z - 4 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' - 1 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #mult(z, z') -{ 0 }-> 1 + #natmult(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z = 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', 0) :|: z = 1 + 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', 0) :|: z - 1 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', #add(1 + z', #natmult(z - 2, z'))) :|: z - 2 >= 0, z' >= 0
   #pred(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #pred(z) -{ 0 }-> 0 :|: z >= 0
   #pred(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #pred(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #pred(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   #succ(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #succ(z) -{ 0 }-> 0 :|: z >= 0
   #succ(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #succ(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #succ(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   dyade(z, z') -{ 1 }-> dyade#1(z, z') :|: z >= 0, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 + mult(@x, z') + dyade(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   mult(z, z') -{ 1 }-> mult#1(z', z) :|: z' >= 0, z >= 0
   mult#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   mult#1(z, z') -{ 1 }-> 1 + times(z', @x) + mult(z', @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   times(z, z') -{ 1 }-> #mult(z, z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {#succ}, {#add}, {#natmult}, {#mult}, {times}, {mult#1,mult}, {dyade,dyade#1}
Previous analysis results are:
  #pred: runtime: O(1) [0], size: O(n^1) [2 + z]

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

(29) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #add(z, z') -{ 0 }-> s :|: s >= 0, s <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0
   #add(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 1 + (1 + (z' - 3)) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 1 + (1 + (1 + (z' - 2))) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> s2 :|: s2 >= 0, s2 <= 1 + (1 + 0) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> z' :|: z = 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' >= 0, v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, v0' >= 0, 0 = v0'
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, v0 >= 0, 1 + (1 + (z' - 3)) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, v0 >= 0, 1 + (1 + (1 + (z' - 2))) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, v0 >= 0, 1 + (1 + 0) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, 1 + (1 + 0) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + 0), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z - 3 >= 0, z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + (z' - 3)) :|: z = 1 + (1 + 0), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x)) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, @x >= 0, 1 + (1 + 0) = 1 + (1 + @x)
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + (z' - 2))) :|: z = 1 + (1 + 0), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> #succ(#succ(#add(1 + (1 + (z - 4)), z'))) :|: z - 4 >= 0, z' >= 0
   #add(z, z') -{ 0 }-> #pred(#succ(#add(1 + (1 + (z - 4)), z'))) :|: z' >= 0, z - 4 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' - 1 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #mult(z, z') -{ 0 }-> 1 + #natmult(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z = 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', 0) :|: z = 1 + 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', 0) :|: z - 1 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', #add(1 + z', #natmult(z - 2, z'))) :|: z - 2 >= 0, z' >= 0
   #pred(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #pred(z) -{ 0 }-> 0 :|: z >= 0
   #pred(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #pred(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #pred(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   #succ(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #succ(z) -{ 0 }-> 0 :|: z >= 0
   #succ(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #succ(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #succ(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   dyade(z, z') -{ 1 }-> dyade#1(z, z') :|: z >= 0, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 + mult(@x, z') + dyade(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   mult(z, z') -{ 1 }-> mult#1(z', z) :|: z' >= 0, z >= 0
   mult#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   mult#1(z, z') -{ 1 }-> 1 + times(z', @x) + mult(z', @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   times(z, z') -{ 1 }-> #mult(z, z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {#succ}, {#add}, {#natmult}, {#mult}, {times}, {mult#1,mult}, {dyade,dyade#1}
Previous analysis results are:
  #pred: runtime: O(1) [0], size: O(n^1) [2 + z]
  #succ: runtime: ?, size: O(n^1) [2 + z]

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

(31) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #add(z, z') -{ 0 }-> s :|: s >= 0, s <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0
   #add(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 1 + (1 + (z' - 3)) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 1 + (1 + (1 + (z' - 2))) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> s2 :|: s2 >= 0, s2 <= 1 + (1 + 0) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> z' :|: z = 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' >= 0, v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, v0' >= 0, 0 = v0'
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, v0 >= 0, 1 + (1 + (z' - 3)) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, v0 >= 0, 1 + (1 + (1 + (z' - 2))) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, v0 >= 0, 1 + (1 + 0) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, 1 + (1 + 0) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + 0), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z - 3 >= 0, z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + (z' - 3)) :|: z = 1 + (1 + 0), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x)) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, @x >= 0, 1 + (1 + 0) = 1 + (1 + @x)
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + (z' - 2))) :|: z = 1 + (1 + 0), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> #succ(#succ(#add(1 + (1 + (z - 4)), z'))) :|: z - 4 >= 0, z' >= 0
   #add(z, z') -{ 0 }-> #pred(#succ(#add(1 + (1 + (z - 4)), z'))) :|: z' >= 0, z - 4 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' - 1 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #mult(z, z') -{ 0 }-> 1 + #natmult(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z = 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', 0) :|: z = 1 + 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', 0) :|: z - 1 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', #add(1 + z', #natmult(z - 2, z'))) :|: z - 2 >= 0, z' >= 0
   #pred(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #pred(z) -{ 0 }-> 0 :|: z >= 0
   #pred(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #pred(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #pred(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   #succ(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #succ(z) -{ 0 }-> 0 :|: z >= 0
   #succ(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #succ(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #succ(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   dyade(z, z') -{ 1 }-> dyade#1(z, z') :|: z >= 0, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 + mult(@x, z') + dyade(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   mult(z, z') -{ 1 }-> mult#1(z', z) :|: z' >= 0, z >= 0
   mult#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   mult#1(z, z') -{ 1 }-> 1 + times(z', @x) + mult(z', @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   times(z, z') -{ 1 }-> #mult(z, z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {#add}, {#natmult}, {#mult}, {times}, {mult#1,mult}, {dyade,dyade#1}
Previous analysis results are:
  #pred: runtime: O(1) [0], size: O(n^1) [2 + z]
  #succ: runtime: O(1) [0], size: O(n^1) [2 + z]

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

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

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

   #add(z, z') -{ 0 }-> s :|: s >= 0, s <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0
   #add(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 1 + (1 + (z' - 3)) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 1 + (1 + (1 + (z' - 2))) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> s2 :|: s2 >= 0, s2 <= 1 + (1 + 0) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> z' :|: z = 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' >= 0, v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, v0' >= 0, 0 = v0'
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, v0 >= 0, 1 + (1 + (z' - 3)) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, v0 >= 0, 1 + (1 + (1 + (z' - 2))) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, v0 >= 0, 1 + (1 + 0) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, 1 + (1 + 0) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + 0), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z - 3 >= 0, z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + (z' - 3)) :|: z = 1 + (1 + 0), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x)) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, @x >= 0, 1 + (1 + 0) = 1 + (1 + @x)
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + (z' - 2))) :|: z = 1 + (1 + 0), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> #succ(#succ(#add(1 + (1 + (z - 4)), z'))) :|: z - 4 >= 0, z' >= 0
   #add(z, z') -{ 0 }-> #pred(#succ(#add(1 + (1 + (z - 4)), z'))) :|: z' >= 0, z - 4 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' - 1 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #mult(z, z') -{ 0 }-> 1 + #natmult(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z = 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', 0) :|: z = 1 + 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', 0) :|: z - 1 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', #add(1 + z', #natmult(z - 2, z'))) :|: z - 2 >= 0, z' >= 0
   #pred(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #pred(z) -{ 0 }-> 0 :|: z >= 0
   #pred(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #pred(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #pred(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   #succ(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #succ(z) -{ 0 }-> 0 :|: z >= 0
   #succ(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #succ(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #succ(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   dyade(z, z') -{ 1 }-> dyade#1(z, z') :|: z >= 0, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 + mult(@x, z') + dyade(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   mult(z, z') -{ 1 }-> mult#1(z', z) :|: z' >= 0, z >= 0
   mult#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   mult#1(z, z') -{ 1 }-> 1 + times(z', @x) + mult(z', @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   times(z, z') -{ 1 }-> #mult(z, z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {#add}, {#natmult}, {#mult}, {times}, {mult#1,mult}, {dyade,dyade#1}
Previous analysis results are:
  #pred: runtime: O(1) [0], size: O(n^1) [2 + z]
  #succ: runtime: O(1) [0], size: O(n^1) [2 + z]

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

(35) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #add(z, z') -{ 0 }-> s :|: s >= 0, s <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0
   #add(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 1 + (1 + (z' - 3)) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 1 + (1 + (1 + (z' - 2))) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> s2 :|: s2 >= 0, s2 <= 1 + (1 + 0) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> z' :|: z = 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' >= 0, v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, v0' >= 0, 0 = v0'
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, v0 >= 0, 1 + (1 + (z' - 3)) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, v0 >= 0, 1 + (1 + (1 + (z' - 2))) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, v0 >= 0, 1 + (1 + 0) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, 1 + (1 + 0) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + 0), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z - 3 >= 0, z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + (z' - 3)) :|: z = 1 + (1 + 0), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x)) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, @x >= 0, 1 + (1 + 0) = 1 + (1 + @x)
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + (z' - 2))) :|: z = 1 + (1 + 0), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> #succ(#succ(#add(1 + (1 + (z - 4)), z'))) :|: z - 4 >= 0, z' >= 0
   #add(z, z') -{ 0 }-> #pred(#succ(#add(1 + (1 + (z - 4)), z'))) :|: z' >= 0, z - 4 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' - 1 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #mult(z, z') -{ 0 }-> 1 + #natmult(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z = 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', 0) :|: z = 1 + 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', 0) :|: z - 1 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', #add(1 + z', #natmult(z - 2, z'))) :|: z - 2 >= 0, z' >= 0
   #pred(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #pred(z) -{ 0 }-> 0 :|: z >= 0
   #pred(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #pred(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #pred(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   #succ(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #succ(z) -{ 0 }-> 0 :|: z >= 0
   #succ(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #succ(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #succ(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   dyade(z, z') -{ 1 }-> dyade#1(z, z') :|: z >= 0, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 + mult(@x, z') + dyade(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   mult(z, z') -{ 1 }-> mult#1(z', z) :|: z' >= 0, z >= 0
   mult#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   mult#1(z, z') -{ 1 }-> 1 + times(z', @x) + mult(z', @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   times(z, z') -{ 1 }-> #mult(z, z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {#add}, {#natmult}, {#mult}, {times}, {mult#1,mult}, {dyade,dyade#1}
Previous analysis results are:
  #pred: runtime: O(1) [0], size: O(n^1) [2 + z]
  #succ: runtime: O(1) [0], size: O(n^1) [2 + z]
  #add: runtime: ?, size: O(n^1) [2*z + z']

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

(37) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #add(z, z') -{ 0 }-> s :|: s >= 0, s <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0
   #add(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 1 + (1 + (z' - 3)) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 1 + (1 + (1 + (z' - 2))) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> s2 :|: s2 >= 0, s2 <= 1 + (1 + 0) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> z' :|: z = 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' >= 0, v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, v0' >= 0, 0 = v0'
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, v0 >= 0, 1 + (1 + (z' - 3)) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, v0 >= 0, 1 + (1 + (1 + (z' - 2))) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, v0 >= 0, 1 + (1 + 0) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, 1 + (1 + 0) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + 0), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z - 3 >= 0, z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + (z' - 3)) :|: z = 1 + (1 + 0), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x)) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, @x >= 0, 1 + (1 + 0) = 1 + (1 + @x)
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + (z' - 2))) :|: z = 1 + (1 + 0), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> #succ(#succ(#add(1 + (1 + (z - 4)), z'))) :|: z - 4 >= 0, z' >= 0
   #add(z, z') -{ 0 }-> #pred(#succ(#add(1 + (1 + (z - 4)), z'))) :|: z' >= 0, z - 4 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' - 1 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #mult(z, z') -{ 0 }-> 1 + #natmult(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z = 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', 0) :|: z = 1 + 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', 0) :|: z - 1 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', #add(1 + z', #natmult(z - 2, z'))) :|: z - 2 >= 0, z' >= 0
   #pred(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #pred(z) -{ 0 }-> 0 :|: z >= 0
   #pred(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #pred(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #pred(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   #succ(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #succ(z) -{ 0 }-> 0 :|: z >= 0
   #succ(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #succ(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #succ(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   dyade(z, z') -{ 1 }-> dyade#1(z, z') :|: z >= 0, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 + mult(@x, z') + dyade(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   mult(z, z') -{ 1 }-> mult#1(z', z) :|: z' >= 0, z >= 0
   mult#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   mult#1(z, z') -{ 1 }-> 1 + times(z', @x) + mult(z', @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   times(z, z') -{ 1 }-> #mult(z, z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {#natmult}, {#mult}, {times}, {mult#1,mult}, {dyade,dyade#1}
Previous analysis results are:
  #pred: runtime: O(1) [0], size: O(n^1) [2 + z]
  #succ: runtime: O(1) [0], size: O(n^1) [2 + z]
  #add: runtime: O(1) [0], size: O(n^1) [2*z + z']

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

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

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

   #add(z, z') -{ 0 }-> s :|: s >= 0, s <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0
   #add(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 1 + (1 + (z' - 3)) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 1 + (1 + (1 + (z' - 2))) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> s10 :|: s8 >= 0, s8 <= 2 * (1 + (1 + (z - 4))) + z', s9 >= 0, s9 <= s8 + 2, s10 >= 0, s10 <= s9 + 2, z' >= 0, z - 4 >= 0
   #add(z, z') -{ 0 }-> s2 :|: s2 >= 0, s2 <= 1 + (1 + 0) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> s7 :|: s5 >= 0, s5 <= 2 * (1 + (1 + (z - 4))) + z', s6 >= 0, s6 <= s5 + 2, s7 >= 0, s7 <= s6 + 2, z - 4 >= 0, z' >= 0
   #add(z, z') -{ 0 }-> z' :|: z = 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' >= 0, v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, v0' >= 0, 0 = v0'
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, v0 >= 0, 1 + (1 + (z' - 3)) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, v0 >= 0, 1 + (1 + (1 + (z' - 2))) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, v0 >= 0, 1 + (1 + 0) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, 1 + (1 + 0) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + 0), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z - 3 >= 0, z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + (z' - 3)) :|: z = 1 + (1 + 0), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x)) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, @x >= 0, 1 + (1 + 0) = 1 + (1 + @x)
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + (z' - 2))) :|: z = 1 + (1 + 0), z' >= 0, z' - 2 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' - 1 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #mult(z, z') -{ 0 }-> 1 + #natmult(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #natmult(z, z') -{ 0 }-> s3 :|: s3 >= 0, s3 <= 2 * (1 + z') + 0, z = 1 + 0, z' >= 0
   #natmult(z, z') -{ 0 }-> s4 :|: s4 >= 0, s4 <= 2 * (1 + z') + 0, z - 1 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z = 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', #add(1 + z', #natmult(z - 2, z'))) :|: z - 2 >= 0, z' >= 0
   #pred(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #pred(z) -{ 0 }-> 0 :|: z >= 0
   #pred(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #pred(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #pred(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   #succ(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #succ(z) -{ 0 }-> 0 :|: z >= 0
   #succ(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #succ(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #succ(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   dyade(z, z') -{ 1 }-> dyade#1(z, z') :|: z >= 0, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 + mult(@x, z') + dyade(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   mult(z, z') -{ 1 }-> mult#1(z', z) :|: z' >= 0, z >= 0
   mult#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   mult#1(z, z') -{ 1 }-> 1 + times(z', @x) + mult(z', @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   times(z, z') -{ 1 }-> #mult(z, z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {#natmult}, {#mult}, {times}, {mult#1,mult}, {dyade,dyade#1}
Previous analysis results are:
  #pred: runtime: O(1) [0], size: O(n^1) [2 + z]
  #succ: runtime: O(1) [0], size: O(n^1) [2 + z]
  #add: runtime: O(1) [0], size: O(n^1) [2*z + z']

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

(41) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #add(z, z') -{ 0 }-> s :|: s >= 0, s <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0
   #add(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 1 + (1 + (z' - 3)) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 1 + (1 + (1 + (z' - 2))) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> s10 :|: s8 >= 0, s8 <= 2 * (1 + (1 + (z - 4))) + z', s9 >= 0, s9 <= s8 + 2, s10 >= 0, s10 <= s9 + 2, z' >= 0, z - 4 >= 0
   #add(z, z') -{ 0 }-> s2 :|: s2 >= 0, s2 <= 1 + (1 + 0) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> s7 :|: s5 >= 0, s5 <= 2 * (1 + (1 + (z - 4))) + z', s6 >= 0, s6 <= s5 + 2, s7 >= 0, s7 <= s6 + 2, z - 4 >= 0, z' >= 0
   #add(z, z') -{ 0 }-> z' :|: z = 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' >= 0, v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, v0' >= 0, 0 = v0'
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, v0 >= 0, 1 + (1 + (z' - 3)) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, v0 >= 0, 1 + (1 + (1 + (z' - 2))) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, v0 >= 0, 1 + (1 + 0) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, 1 + (1 + 0) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + 0), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z - 3 >= 0, z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + (z' - 3)) :|: z = 1 + (1 + 0), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x)) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, @x >= 0, 1 + (1 + 0) = 1 + (1 + @x)
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + (z' - 2))) :|: z = 1 + (1 + 0), z' >= 0, z' - 2 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' - 1 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #mult(z, z') -{ 0 }-> 1 + #natmult(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #natmult(z, z') -{ 0 }-> s3 :|: s3 >= 0, s3 <= 2 * (1 + z') + 0, z = 1 + 0, z' >= 0
   #natmult(z, z') -{ 0 }-> s4 :|: s4 >= 0, s4 <= 2 * (1 + z') + 0, z - 1 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z = 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', #add(1 + z', #natmult(z - 2, z'))) :|: z - 2 >= 0, z' >= 0
   #pred(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #pred(z) -{ 0 }-> 0 :|: z >= 0
   #pred(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #pred(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #pred(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   #succ(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #succ(z) -{ 0 }-> 0 :|: z >= 0
   #succ(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #succ(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #succ(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   dyade(z, z') -{ 1 }-> dyade#1(z, z') :|: z >= 0, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 + mult(@x, z') + dyade(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   mult(z, z') -{ 1 }-> mult#1(z', z) :|: z' >= 0, z >= 0
   mult#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   mult#1(z, z') -{ 1 }-> 1 + times(z', @x) + mult(z', @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   times(z, z') -{ 1 }-> #mult(z, z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {#natmult}, {#mult}, {times}, {mult#1,mult}, {dyade,dyade#1}
Previous analysis results are:
  #pred: runtime: O(1) [0], size: O(n^1) [2 + z]
  #succ: runtime: O(1) [0], size: O(n^1) [2 + z]
  #add: runtime: O(1) [0], size: O(n^1) [2*z + z']
  #natmult: runtime: ?, size: O(n^2) [4 + 4*z + 4*z*z' + 4*z']

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

(43) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #add(z, z') -{ 0 }-> s :|: s >= 0, s <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0
   #add(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 1 + (1 + (z' - 3)) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 1 + (1 + (1 + (z' - 2))) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> s10 :|: s8 >= 0, s8 <= 2 * (1 + (1 + (z - 4))) + z', s9 >= 0, s9 <= s8 + 2, s10 >= 0, s10 <= s9 + 2, z' >= 0, z - 4 >= 0
   #add(z, z') -{ 0 }-> s2 :|: s2 >= 0, s2 <= 1 + (1 + 0) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> s7 :|: s5 >= 0, s5 <= 2 * (1 + (1 + (z - 4))) + z', s6 >= 0, s6 <= s5 + 2, s7 >= 0, s7 <= s6 + 2, z - 4 >= 0, z' >= 0
   #add(z, z') -{ 0 }-> z' :|: z = 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' >= 0, v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, v0' >= 0, 0 = v0'
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, v0 >= 0, 1 + (1 + (z' - 3)) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, v0 >= 0, 1 + (1 + (1 + (z' - 2))) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, v0 >= 0, 1 + (1 + 0) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, 1 + (1 + 0) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + 0), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z - 3 >= 0, z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + (z' - 3)) :|: z = 1 + (1 + 0), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x)) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, @x >= 0, 1 + (1 + 0) = 1 + (1 + @x)
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + (z' - 2))) :|: z = 1 + (1 + 0), z' >= 0, z' - 2 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' - 1 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #mult(z, z') -{ 0 }-> 1 + #natmult(z - 1, z' - 1) :|: z - 1 >= 0, z' - 1 >= 0
   #natmult(z, z') -{ 0 }-> s3 :|: s3 >= 0, s3 <= 2 * (1 + z') + 0, z = 1 + 0, z' >= 0
   #natmult(z, z') -{ 0 }-> s4 :|: s4 >= 0, s4 <= 2 * (1 + z') + 0, z - 1 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z = 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> #add(1 + z', #add(1 + z', #natmult(z - 2, z'))) :|: z - 2 >= 0, z' >= 0
   #pred(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #pred(z) -{ 0 }-> 0 :|: z >= 0
   #pred(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #pred(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #pred(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   #succ(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #succ(z) -{ 0 }-> 0 :|: z >= 0
   #succ(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #succ(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #succ(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   dyade(z, z') -{ 1 }-> dyade#1(z, z') :|: z >= 0, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 + mult(@x, z') + dyade(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   mult(z, z') -{ 1 }-> mult#1(z', z) :|: z' >= 0, z >= 0
   mult#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   mult#1(z, z') -{ 1 }-> 1 + times(z', @x) + mult(z', @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   times(z, z') -{ 1 }-> #mult(z, z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {#mult}, {times}, {mult#1,mult}, {dyade,dyade#1}
Previous analysis results are:
  #pred: runtime: O(1) [0], size: O(n^1) [2 + z]
  #succ: runtime: O(1) [0], size: O(n^1) [2 + z]
  #add: runtime: O(1) [0], size: O(n^1) [2*z + z']
  #natmult: runtime: O(1) [0], size: O(n^2) [4 + 4*z + 4*z*z' + 4*z']

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

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

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

   #add(z, z') -{ 0 }-> s :|: s >= 0, s <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0
   #add(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 1 + (1 + (z' - 3)) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 1 + (1 + (1 + (z' - 2))) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> s10 :|: s8 >= 0, s8 <= 2 * (1 + (1 + (z - 4))) + z', s9 >= 0, s9 <= s8 + 2, s10 >= 0, s10 <= s9 + 2, z' >= 0, z - 4 >= 0
   #add(z, z') -{ 0 }-> s2 :|: s2 >= 0, s2 <= 1 + (1 + 0) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> s7 :|: s5 >= 0, s5 <= 2 * (1 + (1 + (z - 4))) + z', s6 >= 0, s6 <= s5 + 2, s7 >= 0, s7 <= s6 + 2, z - 4 >= 0, z' >= 0
   #add(z, z') -{ 0 }-> z' :|: z = 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' >= 0, v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, v0' >= 0, 0 = v0'
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, v0 >= 0, 1 + (1 + (z' - 3)) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, v0 >= 0, 1 + (1 + (1 + (z' - 2))) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, v0 >= 0, 1 + (1 + 0) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, 1 + (1 + 0) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + 0), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z - 3 >= 0, z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + (z' - 3)) :|: z = 1 + (1 + 0), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x)) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, @x >= 0, 1 + (1 + 0) = 1 + (1 + @x)
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + (z' - 2))) :|: z = 1 + (1 + 0), z' >= 0, z' - 2 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' - 1 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #mult(z, z') -{ 0 }-> 1 + s11 :|: s11 >= 0, s11 <= 4 * (z' - 1) + 4 * ((z' - 1) * (z - 1)) + 4 * (z - 1) + 4, z - 1 >= 0, z' - 1 >= 0
   #natmult(z, z') -{ 0 }-> s14 :|: s12 >= 0, s12 <= 4 * z' + 4 * (z' * (z - 2)) + 4 * (z - 2) + 4, s13 >= 0, s13 <= 2 * (1 + z') + s12, s14 >= 0, s14 <= 2 * (1 + z') + s13, z - 2 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> s3 :|: s3 >= 0, s3 <= 2 * (1 + z') + 0, z = 1 + 0, z' >= 0
   #natmult(z, z') -{ 0 }-> s4 :|: s4 >= 0, s4 <= 2 * (1 + z') + 0, z - 1 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z = 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #pred(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #pred(z) -{ 0 }-> 0 :|: z >= 0
   #pred(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #pred(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #pred(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   #succ(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #succ(z) -{ 0 }-> 0 :|: z >= 0
   #succ(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #succ(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #succ(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   dyade(z, z') -{ 1 }-> dyade#1(z, z') :|: z >= 0, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 + mult(@x, z') + dyade(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   mult(z, z') -{ 1 }-> mult#1(z', z) :|: z' >= 0, z >= 0
   mult#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   mult#1(z, z') -{ 1 }-> 1 + times(z', @x) + mult(z', @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   times(z, z') -{ 1 }-> #mult(z, z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {#mult}, {times}, {mult#1,mult}, {dyade,dyade#1}
Previous analysis results are:
  #pred: runtime: O(1) [0], size: O(n^1) [2 + z]
  #succ: runtime: O(1) [0], size: O(n^1) [2 + z]
  #add: runtime: O(1) [0], size: O(n^1) [2*z + z']
  #natmult: runtime: O(1) [0], size: O(n^2) [4 + 4*z + 4*z*z' + 4*z']

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

(47) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #add(z, z') -{ 0 }-> s :|: s >= 0, s <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0
   #add(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 1 + (1 + (z' - 3)) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 1 + (1 + (1 + (z' - 2))) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> s10 :|: s8 >= 0, s8 <= 2 * (1 + (1 + (z - 4))) + z', s9 >= 0, s9 <= s8 + 2, s10 >= 0, s10 <= s9 + 2, z' >= 0, z - 4 >= 0
   #add(z, z') -{ 0 }-> s2 :|: s2 >= 0, s2 <= 1 + (1 + 0) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> s7 :|: s5 >= 0, s5 <= 2 * (1 + (1 + (z - 4))) + z', s6 >= 0, s6 <= s5 + 2, s7 >= 0, s7 <= s6 + 2, z - 4 >= 0, z' >= 0
   #add(z, z') -{ 0 }-> z' :|: z = 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' >= 0, v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, v0' >= 0, 0 = v0'
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, v0 >= 0, 1 + (1 + (z' - 3)) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, v0 >= 0, 1 + (1 + (1 + (z' - 2))) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, v0 >= 0, 1 + (1 + 0) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, 1 + (1 + 0) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + 0), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z - 3 >= 0, z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + (z' - 3)) :|: z = 1 + (1 + 0), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x)) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, @x >= 0, 1 + (1 + 0) = 1 + (1 + @x)
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + (z' - 2))) :|: z = 1 + (1 + 0), z' >= 0, z' - 2 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' - 1 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #mult(z, z') -{ 0 }-> 1 + s11 :|: s11 >= 0, s11 <= 4 * (z' - 1) + 4 * ((z' - 1) * (z - 1)) + 4 * (z - 1) + 4, z - 1 >= 0, z' - 1 >= 0
   #natmult(z, z') -{ 0 }-> s14 :|: s12 >= 0, s12 <= 4 * z' + 4 * (z' * (z - 2)) + 4 * (z - 2) + 4, s13 >= 0, s13 <= 2 * (1 + z') + s12, s14 >= 0, s14 <= 2 * (1 + z') + s13, z - 2 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> s3 :|: s3 >= 0, s3 <= 2 * (1 + z') + 0, z = 1 + 0, z' >= 0
   #natmult(z, z') -{ 0 }-> s4 :|: s4 >= 0, s4 <= 2 * (1 + z') + 0, z - 1 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z = 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #pred(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #pred(z) -{ 0 }-> 0 :|: z >= 0
   #pred(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #pred(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #pred(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   #succ(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #succ(z) -{ 0 }-> 0 :|: z >= 0
   #succ(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #succ(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #succ(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   dyade(z, z') -{ 1 }-> dyade#1(z, z') :|: z >= 0, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 + mult(@x, z') + dyade(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   mult(z, z') -{ 1 }-> mult#1(z', z) :|: z' >= 0, z >= 0
   mult#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   mult#1(z, z') -{ 1 }-> 1 + times(z', @x) + mult(z', @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   times(z, z') -{ 1 }-> #mult(z, z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {#mult}, {times}, {mult#1,mult}, {dyade,dyade#1}
Previous analysis results are:
  #pred: runtime: O(1) [0], size: O(n^1) [2 + z]
  #succ: runtime: O(1) [0], size: O(n^1) [2 + z]
  #add: runtime: O(1) [0], size: O(n^1) [2*z + z']
  #natmult: runtime: O(1) [0], size: O(n^2) [4 + 4*z + 4*z*z' + 4*z']
  #mult: runtime: ?, size: O(n^2) [1 + 4*z*z']

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

(49) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   #add(z, z') -{ 0 }-> s :|: s >= 0, s <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0
   #add(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 1 + (1 + (z' - 3)) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 1 + (1 + (1 + (z' - 2))) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> s10 :|: s8 >= 0, s8 <= 2 * (1 + (1 + (z - 4))) + z', s9 >= 0, s9 <= s8 + 2, s10 >= 0, s10 <= s9 + 2, z' >= 0, z - 4 >= 0
   #add(z, z') -{ 0 }-> s2 :|: s2 >= 0, s2 <= 1 + (1 + 0) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> s7 :|: s5 >= 0, s5 <= 2 * (1 + (1 + (z - 4))) + z', s6 >= 0, s6 <= s5 + 2, s7 >= 0, s7 <= s6 + 2, z - 4 >= 0, z' >= 0
   #add(z, z') -{ 0 }-> z' :|: z = 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' >= 0, v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, v0' >= 0, 0 = v0'
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, v0 >= 0, 1 + (1 + (z' - 3)) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, v0 >= 0, 1 + (1 + (1 + (z' - 2))) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, v0 >= 0, 1 + (1 + 0) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, 1 + (1 + 0) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + 0), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z - 3 >= 0, z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + (z' - 3)) :|: z = 1 + (1 + 0), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x)) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, @x >= 0, 1 + (1 + 0) = 1 + (1 + @x)
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + (z' - 2))) :|: z = 1 + (1 + 0), z' >= 0, z' - 2 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' - 1 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #mult(z, z') -{ 0 }-> 1 + s11 :|: s11 >= 0, s11 <= 4 * (z' - 1) + 4 * ((z' - 1) * (z - 1)) + 4 * (z - 1) + 4, z - 1 >= 0, z' - 1 >= 0
   #natmult(z, z') -{ 0 }-> s14 :|: s12 >= 0, s12 <= 4 * z' + 4 * (z' * (z - 2)) + 4 * (z - 2) + 4, s13 >= 0, s13 <= 2 * (1 + z') + s12, s14 >= 0, s14 <= 2 * (1 + z') + s13, z - 2 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> s3 :|: s3 >= 0, s3 <= 2 * (1 + z') + 0, z = 1 + 0, z' >= 0
   #natmult(z, z') -{ 0 }-> s4 :|: s4 >= 0, s4 <= 2 * (1 + z') + 0, z - 1 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z = 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #pred(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #pred(z) -{ 0 }-> 0 :|: z >= 0
   #pred(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #pred(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #pred(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   #succ(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #succ(z) -{ 0 }-> 0 :|: z >= 0
   #succ(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #succ(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #succ(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   dyade(z, z') -{ 1 }-> dyade#1(z, z') :|: z >= 0, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 + mult(@x, z') + dyade(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   mult(z, z') -{ 1 }-> mult#1(z', z) :|: z' >= 0, z >= 0
   mult#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   mult#1(z, z') -{ 1 }-> 1 + times(z', @x) + mult(z', @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   times(z, z') -{ 1 }-> #mult(z, z') :|: z >= 0, z' >= 0

Function symbols to be analyzed: {times}, {mult#1,mult}, {dyade,dyade#1}
Previous analysis results are:
  #pred: runtime: O(1) [0], size: O(n^1) [2 + z]
  #succ: runtime: O(1) [0], size: O(n^1) [2 + z]
  #add: runtime: O(1) [0], size: O(n^1) [2*z + z']
  #natmult: runtime: O(1) [0], size: O(n^2) [4 + 4*z + 4*z*z' + 4*z']
  #mult: runtime: O(1) [0], size: O(n^2) [1 + 4*z*z']

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

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

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

   #add(z, z') -{ 0 }-> s :|: s >= 0, s <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0
   #add(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 1 + (1 + (z' - 3)) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 1 + (1 + (1 + (z' - 2))) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> s10 :|: s8 >= 0, s8 <= 2 * (1 + (1 + (z - 4))) + z', s9 >= 0, s9 <= s8 + 2, s10 >= 0, s10 <= s9 + 2, z' >= 0, z - 4 >= 0
   #add(z, z') -{ 0 }-> s2 :|: s2 >= 0, s2 <= 1 + (1 + 0) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> s7 :|: s5 >= 0, s5 <= 2 * (1 + (1 + (z - 4))) + z', s6 >= 0, s6 <= s5 + 2, s7 >= 0, s7 <= s6 + 2, z - 4 >= 0, z' >= 0
   #add(z, z') -{ 0 }-> z' :|: z = 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' >= 0, v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, v0' >= 0, 0 = v0'
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, v0 >= 0, 1 + (1 + (z' - 3)) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, v0 >= 0, 1 + (1 + (1 + (z' - 2))) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, v0 >= 0, 1 + (1 + 0) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, 1 + (1 + 0) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + 0), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z - 3 >= 0, z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + (z' - 3)) :|: z = 1 + (1 + 0), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x)) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, @x >= 0, 1 + (1 + 0) = 1 + (1 + @x)
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + (z' - 2))) :|: z = 1 + (1 + 0), z' >= 0, z' - 2 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' - 1 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #mult(z, z') -{ 0 }-> 1 + s11 :|: s11 >= 0, s11 <= 4 * (z' - 1) + 4 * ((z' - 1) * (z - 1)) + 4 * (z - 1) + 4, z - 1 >= 0, z' - 1 >= 0
   #natmult(z, z') -{ 0 }-> s14 :|: s12 >= 0, s12 <= 4 * z' + 4 * (z' * (z - 2)) + 4 * (z - 2) + 4, s13 >= 0, s13 <= 2 * (1 + z') + s12, s14 >= 0, s14 <= 2 * (1 + z') + s13, z - 2 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> s3 :|: s3 >= 0, s3 <= 2 * (1 + z') + 0, z = 1 + 0, z' >= 0
   #natmult(z, z') -{ 0 }-> s4 :|: s4 >= 0, s4 <= 2 * (1 + z') + 0, z - 1 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z = 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #pred(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #pred(z) -{ 0 }-> 0 :|: z >= 0
   #pred(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #pred(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #pred(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   #succ(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #succ(z) -{ 0 }-> 0 :|: z >= 0
   #succ(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #succ(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #succ(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   dyade(z, z') -{ 1 }-> dyade#1(z, z') :|: z >= 0, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 + mult(@x, z') + dyade(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   mult(z, z') -{ 1 }-> mult#1(z', z) :|: z' >= 0, z >= 0
   mult#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   mult#1(z, z') -{ 1 }-> 1 + times(z', @x) + mult(z', @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   times(z, z') -{ 1 }-> s15 :|: s15 >= 0, s15 <= 4 * (z' * z) + 1, z >= 0, z' >= 0

Function symbols to be analyzed: {times}, {mult#1,mult}, {dyade,dyade#1}
Previous analysis results are:
  #pred: runtime: O(1) [0], size: O(n^1) [2 + z]
  #succ: runtime: O(1) [0], size: O(n^1) [2 + z]
  #add: runtime: O(1) [0], size: O(n^1) [2*z + z']
  #natmult: runtime: O(1) [0], size: O(n^2) [4 + 4*z + 4*z*z' + 4*z']
  #mult: runtime: O(1) [0], size: O(n^2) [1 + 4*z*z']

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

(53) 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: 1 + 4*z*z'

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

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

   #add(z, z') -{ 0 }-> s :|: s >= 0, s <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0
   #add(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 1 + (1 + (z' - 3)) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 1 + (1 + (1 + (z' - 2))) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> s10 :|: s8 >= 0, s8 <= 2 * (1 + (1 + (z - 4))) + z', s9 >= 0, s9 <= s8 + 2, s10 >= 0, s10 <= s9 + 2, z' >= 0, z - 4 >= 0
   #add(z, z') -{ 0 }-> s2 :|: s2 >= 0, s2 <= 1 + (1 + 0) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> s7 :|: s5 >= 0, s5 <= 2 * (1 + (1 + (z - 4))) + z', s6 >= 0, s6 <= s5 + 2, s7 >= 0, s7 <= s6 + 2, z - 4 >= 0, z' >= 0
   #add(z, z') -{ 0 }-> z' :|: z = 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' >= 0, v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, v0' >= 0, 0 = v0'
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, v0 >= 0, 1 + (1 + (z' - 3)) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, v0 >= 0, 1 + (1 + (1 + (z' - 2))) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, v0 >= 0, 1 + (1 + 0) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, 1 + (1 + 0) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + 0), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z - 3 >= 0, z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + (z' - 3)) :|: z = 1 + (1 + 0), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x)) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, @x >= 0, 1 + (1 + 0) = 1 + (1 + @x)
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + (z' - 2))) :|: z = 1 + (1 + 0), z' >= 0, z' - 2 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' - 1 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #mult(z, z') -{ 0 }-> 1 + s11 :|: s11 >= 0, s11 <= 4 * (z' - 1) + 4 * ((z' - 1) * (z - 1)) + 4 * (z - 1) + 4, z - 1 >= 0, z' - 1 >= 0
   #natmult(z, z') -{ 0 }-> s14 :|: s12 >= 0, s12 <= 4 * z' + 4 * (z' * (z - 2)) + 4 * (z - 2) + 4, s13 >= 0, s13 <= 2 * (1 + z') + s12, s14 >= 0, s14 <= 2 * (1 + z') + s13, z - 2 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> s3 :|: s3 >= 0, s3 <= 2 * (1 + z') + 0, z = 1 + 0, z' >= 0
   #natmult(z, z') -{ 0 }-> s4 :|: s4 >= 0, s4 <= 2 * (1 + z') + 0, z - 1 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z = 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #pred(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #pred(z) -{ 0 }-> 0 :|: z >= 0
   #pred(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #pred(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #pred(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   #succ(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #succ(z) -{ 0 }-> 0 :|: z >= 0
   #succ(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #succ(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #succ(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   dyade(z, z') -{ 1 }-> dyade#1(z, z') :|: z >= 0, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 + mult(@x, z') + dyade(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   mult(z, z') -{ 1 }-> mult#1(z', z) :|: z' >= 0, z >= 0
   mult#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   mult#1(z, z') -{ 1 }-> 1 + times(z', @x) + mult(z', @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   times(z, z') -{ 1 }-> s15 :|: s15 >= 0, s15 <= 4 * (z' * z) + 1, z >= 0, z' >= 0

Function symbols to be analyzed: {times}, {mult#1,mult}, {dyade,dyade#1}
Previous analysis results are:
  #pred: runtime: O(1) [0], size: O(n^1) [2 + z]
  #succ: runtime: O(1) [0], size: O(n^1) [2 + z]
  #add: runtime: O(1) [0], size: O(n^1) [2*z + z']
  #natmult: runtime: O(1) [0], size: O(n^2) [4 + 4*z + 4*z*z' + 4*z']
  #mult: runtime: O(1) [0], size: O(n^2) [1 + 4*z*z']
  times: runtime: ?, size: O(n^2) [1 + 4*z*z']

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

(55) 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: 1

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

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

   #add(z, z') -{ 0 }-> s :|: s >= 0, s <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0
   #add(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 1 + (1 + (z' - 3)) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 1 + (1 + (1 + (z' - 2))) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> s10 :|: s8 >= 0, s8 <= 2 * (1 + (1 + (z - 4))) + z', s9 >= 0, s9 <= s8 + 2, s10 >= 0, s10 <= s9 + 2, z' >= 0, z - 4 >= 0
   #add(z, z') -{ 0 }-> s2 :|: s2 >= 0, s2 <= 1 + (1 + 0) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> s7 :|: s5 >= 0, s5 <= 2 * (1 + (1 + (z - 4))) + z', s6 >= 0, s6 <= s5 + 2, s7 >= 0, s7 <= s6 + 2, z - 4 >= 0, z' >= 0
   #add(z, z') -{ 0 }-> z' :|: z = 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' >= 0, v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, v0' >= 0, 0 = v0'
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, v0 >= 0, 1 + (1 + (z' - 3)) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, v0 >= 0, 1 + (1 + (1 + (z' - 2))) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, v0 >= 0, 1 + (1 + 0) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, 1 + (1 + 0) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + 0), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z - 3 >= 0, z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + (z' - 3)) :|: z = 1 + (1 + 0), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x)) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, @x >= 0, 1 + (1 + 0) = 1 + (1 + @x)
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + (z' - 2))) :|: z = 1 + (1 + 0), z' >= 0, z' - 2 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' - 1 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #mult(z, z') -{ 0 }-> 1 + s11 :|: s11 >= 0, s11 <= 4 * (z' - 1) + 4 * ((z' - 1) * (z - 1)) + 4 * (z - 1) + 4, z - 1 >= 0, z' - 1 >= 0
   #natmult(z, z') -{ 0 }-> s14 :|: s12 >= 0, s12 <= 4 * z' + 4 * (z' * (z - 2)) + 4 * (z - 2) + 4, s13 >= 0, s13 <= 2 * (1 + z') + s12, s14 >= 0, s14 <= 2 * (1 + z') + s13, z - 2 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> s3 :|: s3 >= 0, s3 <= 2 * (1 + z') + 0, z = 1 + 0, z' >= 0
   #natmult(z, z') -{ 0 }-> s4 :|: s4 >= 0, s4 <= 2 * (1 + z') + 0, z - 1 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z = 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #pred(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #pred(z) -{ 0 }-> 0 :|: z >= 0
   #pred(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #pred(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #pred(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   #succ(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #succ(z) -{ 0 }-> 0 :|: z >= 0
   #succ(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #succ(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #succ(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   dyade(z, z') -{ 1 }-> dyade#1(z, z') :|: z >= 0, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 + mult(@x, z') + dyade(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   mult(z, z') -{ 1 }-> mult#1(z', z) :|: z' >= 0, z >= 0
   mult#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   mult#1(z, z') -{ 1 }-> 1 + times(z', @x) + mult(z', @xs) :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   times(z, z') -{ 1 }-> s15 :|: s15 >= 0, s15 <= 4 * (z' * z) + 1, z >= 0, z' >= 0

Function symbols to be analyzed: {mult#1,mult}, {dyade,dyade#1}
Previous analysis results are:
  #pred: runtime: O(1) [0], size: O(n^1) [2 + z]
  #succ: runtime: O(1) [0], size: O(n^1) [2 + z]
  #add: runtime: O(1) [0], size: O(n^1) [2*z + z']
  #natmult: runtime: O(1) [0], size: O(n^2) [4 + 4*z + 4*z*z' + 4*z']
  #mult: runtime: O(1) [0], size: O(n^2) [1 + 4*z*z']
  times: runtime: O(1) [1], size: O(n^2) [1 + 4*z*z']

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

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

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

   #add(z, z') -{ 0 }-> s :|: s >= 0, s <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0
   #add(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 1 + (1 + (z' - 3)) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 1 + (1 + (1 + (z' - 2))) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> s10 :|: s8 >= 0, s8 <= 2 * (1 + (1 + (z - 4))) + z', s9 >= 0, s9 <= s8 + 2, s10 >= 0, s10 <= s9 + 2, z' >= 0, z - 4 >= 0
   #add(z, z') -{ 0 }-> s2 :|: s2 >= 0, s2 <= 1 + (1 + 0) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> s7 :|: s5 >= 0, s5 <= 2 * (1 + (1 + (z - 4))) + z', s6 >= 0, s6 <= s5 + 2, s7 >= 0, s7 <= s6 + 2, z - 4 >= 0, z' >= 0
   #add(z, z') -{ 0 }-> z' :|: z = 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' >= 0, v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, v0' >= 0, 0 = v0'
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, v0 >= 0, 1 + (1 + (z' - 3)) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, v0 >= 0, 1 + (1 + (1 + (z' - 2))) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, v0 >= 0, 1 + (1 + 0) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, 1 + (1 + 0) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + 0), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z - 3 >= 0, z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + (z' - 3)) :|: z = 1 + (1 + 0), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x)) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, @x >= 0, 1 + (1 + 0) = 1 + (1 + @x)
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + (z' - 2))) :|: z = 1 + (1 + 0), z' >= 0, z' - 2 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' - 1 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #mult(z, z') -{ 0 }-> 1 + s11 :|: s11 >= 0, s11 <= 4 * (z' - 1) + 4 * ((z' - 1) * (z - 1)) + 4 * (z - 1) + 4, z - 1 >= 0, z' - 1 >= 0
   #natmult(z, z') -{ 0 }-> s14 :|: s12 >= 0, s12 <= 4 * z' + 4 * (z' * (z - 2)) + 4 * (z - 2) + 4, s13 >= 0, s13 <= 2 * (1 + z') + s12, s14 >= 0, s14 <= 2 * (1 + z') + s13, z - 2 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> s3 :|: s3 >= 0, s3 <= 2 * (1 + z') + 0, z = 1 + 0, z' >= 0
   #natmult(z, z') -{ 0 }-> s4 :|: s4 >= 0, s4 <= 2 * (1 + z') + 0, z - 1 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z = 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #pred(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #pred(z) -{ 0 }-> 0 :|: z >= 0
   #pred(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #pred(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #pred(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   #succ(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #succ(z) -{ 0 }-> 0 :|: z >= 0
   #succ(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #succ(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #succ(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   dyade(z, z') -{ 1 }-> dyade#1(z, z') :|: z >= 0, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 + mult(@x, z') + dyade(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   mult(z, z') -{ 1 }-> mult#1(z', z) :|: z' >= 0, z >= 0
   mult#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   mult#1(z, z') -{ 2 }-> 1 + s16 + mult(z', @xs) :|: s16 >= 0, s16 <= 4 * (@x * z') + 1, @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   times(z, z') -{ 1 }-> s15 :|: s15 >= 0, s15 <= 4 * (z' * z) + 1, z >= 0, z' >= 0

Function symbols to be analyzed: {mult#1,mult}, {dyade,dyade#1}
Previous analysis results are:
  #pred: runtime: O(1) [0], size: O(n^1) [2 + z]
  #succ: runtime: O(1) [0], size: O(n^1) [2 + z]
  #add: runtime: O(1) [0], size: O(n^1) [2*z + z']
  #natmult: runtime: O(1) [0], size: O(n^2) [4 + 4*z + 4*z*z' + 4*z']
  #mult: runtime: O(1) [0], size: O(n^2) [1 + 4*z*z']
  times: runtime: O(1) [1], size: O(n^2) [1 + 4*z*z']

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

(59) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

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

   #add(z, z') -{ 0 }-> s :|: s >= 0, s <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0
   #add(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 1 + (1 + (z' - 3)) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 1 + (1 + (1 + (z' - 2))) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> s10 :|: s8 >= 0, s8 <= 2 * (1 + (1 + (z - 4))) + z', s9 >= 0, s9 <= s8 + 2, s10 >= 0, s10 <= s9 + 2, z' >= 0, z - 4 >= 0
   #add(z, z') -{ 0 }-> s2 :|: s2 >= 0, s2 <= 1 + (1 + 0) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> s7 :|: s5 >= 0, s5 <= 2 * (1 + (1 + (z - 4))) + z', s6 >= 0, s6 <= s5 + 2, s7 >= 0, s7 <= s6 + 2, z - 4 >= 0, z' >= 0
   #add(z, z') -{ 0 }-> z' :|: z = 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' >= 0, v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, v0' >= 0, 0 = v0'
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, v0 >= 0, 1 + (1 + (z' - 3)) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, v0 >= 0, 1 + (1 + (1 + (z' - 2))) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, v0 >= 0, 1 + (1 + 0) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, 1 + (1 + 0) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + 0), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z - 3 >= 0, z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + (z' - 3)) :|: z = 1 + (1 + 0), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x)) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, @x >= 0, 1 + (1 + 0) = 1 + (1 + @x)
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + (z' - 2))) :|: z = 1 + (1 + 0), z' >= 0, z' - 2 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' - 1 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #mult(z, z') -{ 0 }-> 1 + s11 :|: s11 >= 0, s11 <= 4 * (z' - 1) + 4 * ((z' - 1) * (z - 1)) + 4 * (z - 1) + 4, z - 1 >= 0, z' - 1 >= 0
   #natmult(z, z') -{ 0 }-> s14 :|: s12 >= 0, s12 <= 4 * z' + 4 * (z' * (z - 2)) + 4 * (z - 2) + 4, s13 >= 0, s13 <= 2 * (1 + z') + s12, s14 >= 0, s14 <= 2 * (1 + z') + s13, z - 2 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> s3 :|: s3 >= 0, s3 <= 2 * (1 + z') + 0, z = 1 + 0, z' >= 0
   #natmult(z, z') -{ 0 }-> s4 :|: s4 >= 0, s4 <= 2 * (1 + z') + 0, z - 1 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z = 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #pred(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #pred(z) -{ 0 }-> 0 :|: z >= 0
   #pred(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #pred(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #pred(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   #succ(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #succ(z) -{ 0 }-> 0 :|: z >= 0
   #succ(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #succ(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #succ(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   dyade(z, z') -{ 1 }-> dyade#1(z, z') :|: z >= 0, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 + mult(@x, z') + dyade(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   mult(z, z') -{ 1 }-> mult#1(z', z) :|: z' >= 0, z >= 0
   mult#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   mult#1(z, z') -{ 2 }-> 1 + s16 + mult(z', @xs) :|: s16 >= 0, s16 <= 4 * (@x * z') + 1, @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   times(z, z') -{ 1 }-> s15 :|: s15 >= 0, s15 <= 4 * (z' * z) + 1, z >= 0, z' >= 0

Function symbols to be analyzed: {mult#1,mult}, {dyade,dyade#1}
Previous analysis results are:
  #pred: runtime: O(1) [0], size: O(n^1) [2 + z]
  #succ: runtime: O(1) [0], size: O(n^1) [2 + z]
  #add: runtime: O(1) [0], size: O(n^1) [2*z + z']
  #natmult: runtime: O(1) [0], size: O(n^2) [4 + 4*z + 4*z*z' + 4*z']
  #mult: runtime: O(1) [0], size: O(n^2) [1 + 4*z*z']
  times: runtime: O(1) [1], size: O(n^2) [1 + 4*z*z']
  mult#1: runtime: ?, size: INF
  mult: runtime: ?, size: INF

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

(61) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

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

   #add(z, z') -{ 0 }-> s :|: s >= 0, s <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0
   #add(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 1 + (1 + (z' - 3)) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 1 + (1 + (1 + (z' - 2))) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> s10 :|: s8 >= 0, s8 <= 2 * (1 + (1 + (z - 4))) + z', s9 >= 0, s9 <= s8 + 2, s10 >= 0, s10 <= s9 + 2, z' >= 0, z - 4 >= 0
   #add(z, z') -{ 0 }-> s2 :|: s2 >= 0, s2 <= 1 + (1 + 0) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> s7 :|: s5 >= 0, s5 <= 2 * (1 + (1 + (z - 4))) + z', s6 >= 0, s6 <= s5 + 2, s7 >= 0, s7 <= s6 + 2, z - 4 >= 0, z' >= 0
   #add(z, z') -{ 0 }-> z' :|: z = 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' >= 0, v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, v0' >= 0, 0 = v0'
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, v0 >= 0, 1 + (1 + (z' - 3)) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, v0 >= 0, 1 + (1 + (1 + (z' - 2))) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, v0 >= 0, 1 + (1 + 0) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, 1 + (1 + 0) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + 0), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z - 3 >= 0, z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + (z' - 3)) :|: z = 1 + (1 + 0), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x)) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, @x >= 0, 1 + (1 + 0) = 1 + (1 + @x)
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + (z' - 2))) :|: z = 1 + (1 + 0), z' >= 0, z' - 2 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' - 1 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #mult(z, z') -{ 0 }-> 1 + s11 :|: s11 >= 0, s11 <= 4 * (z' - 1) + 4 * ((z' - 1) * (z - 1)) + 4 * (z - 1) + 4, z - 1 >= 0, z' - 1 >= 0
   #natmult(z, z') -{ 0 }-> s14 :|: s12 >= 0, s12 <= 4 * z' + 4 * (z' * (z - 2)) + 4 * (z - 2) + 4, s13 >= 0, s13 <= 2 * (1 + z') + s12, s14 >= 0, s14 <= 2 * (1 + z') + s13, z - 2 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> s3 :|: s3 >= 0, s3 <= 2 * (1 + z') + 0, z = 1 + 0, z' >= 0
   #natmult(z, z') -{ 0 }-> s4 :|: s4 >= 0, s4 <= 2 * (1 + z') + 0, z - 1 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z = 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #pred(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #pred(z) -{ 0 }-> 0 :|: z >= 0
   #pred(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #pred(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #pred(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   #succ(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #succ(z) -{ 0 }-> 0 :|: z >= 0
   #succ(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #succ(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #succ(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   dyade(z, z') -{ 1 }-> dyade#1(z, z') :|: z >= 0, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 + mult(@x, z') + dyade(@xs, z') :|: @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   mult(z, z') -{ 1 }-> mult#1(z', z) :|: z' >= 0, z >= 0
   mult#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   mult#1(z, z') -{ 2 }-> 1 + s16 + mult(z', @xs) :|: s16 >= 0, s16 <= 4 * (@x * z') + 1, @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   times(z, z') -{ 1 }-> s15 :|: s15 >= 0, s15 <= 4 * (z' * z) + 1, z >= 0, z' >= 0

Function symbols to be analyzed: {dyade,dyade#1}
Previous analysis results are:
  #pred: runtime: O(1) [0], size: O(n^1) [2 + z]
  #succ: runtime: O(1) [0], size: O(n^1) [2 + z]
  #add: runtime: O(1) [0], size: O(n^1) [2*z + z']
  #natmult: runtime: O(1) [0], size: O(n^2) [4 + 4*z + 4*z*z' + 4*z']
  #mult: runtime: O(1) [0], size: O(n^2) [1 + 4*z*z']
  times: runtime: O(1) [1], size: O(n^2) [1 + 4*z*z']
  mult#1: runtime: O(n^1) [5 + 3*z], size: INF
  mult: runtime: O(n^1) [6 + 3*z'], size: INF

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

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

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

   #add(z, z') -{ 0 }-> s :|: s >= 0, s <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0
   #add(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 1 + (1 + (z' - 3)) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 1 + (1 + (1 + (z' - 2))) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> s10 :|: s8 >= 0, s8 <= 2 * (1 + (1 + (z - 4))) + z', s9 >= 0, s9 <= s8 + 2, s10 >= 0, s10 <= s9 + 2, z' >= 0, z - 4 >= 0
   #add(z, z') -{ 0 }-> s2 :|: s2 >= 0, s2 <= 1 + (1 + 0) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> s7 :|: s5 >= 0, s5 <= 2 * (1 + (1 + (z - 4))) + z', s6 >= 0, s6 <= s5 + 2, s7 >= 0, s7 <= s6 + 2, z - 4 >= 0, z' >= 0
   #add(z, z') -{ 0 }-> z' :|: z = 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' >= 0, v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, v0' >= 0, 0 = v0'
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, v0 >= 0, 1 + (1 + (z' - 3)) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, v0 >= 0, 1 + (1 + (1 + (z' - 2))) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, v0 >= 0, 1 + (1 + 0) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, 1 + (1 + 0) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + 0), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z - 3 >= 0, z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + (z' - 3)) :|: z = 1 + (1 + 0), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x)) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, @x >= 0, 1 + (1 + 0) = 1 + (1 + @x)
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + (z' - 2))) :|: z = 1 + (1 + 0), z' >= 0, z' - 2 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' - 1 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #mult(z, z') -{ 0 }-> 1 + s11 :|: s11 >= 0, s11 <= 4 * (z' - 1) + 4 * ((z' - 1) * (z - 1)) + 4 * (z - 1) + 4, z - 1 >= 0, z' - 1 >= 0
   #natmult(z, z') -{ 0 }-> s14 :|: s12 >= 0, s12 <= 4 * z' + 4 * (z' * (z - 2)) + 4 * (z - 2) + 4, s13 >= 0, s13 <= 2 * (1 + z') + s12, s14 >= 0, s14 <= 2 * (1 + z') + s13, z - 2 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> s3 :|: s3 >= 0, s3 <= 2 * (1 + z') + 0, z = 1 + 0, z' >= 0
   #natmult(z, z') -{ 0 }-> s4 :|: s4 >= 0, s4 <= 2 * (1 + z') + 0, z - 1 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z = 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #pred(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #pred(z) -{ 0 }-> 0 :|: z >= 0
   #pred(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #pred(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #pred(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   #succ(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #succ(z) -{ 0 }-> 0 :|: z >= 0
   #succ(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #succ(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #succ(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   dyade(z, z') -{ 1 }-> dyade#1(z, z') :|: z >= 0, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   dyade#1(z, z') -{ 7 + 3*z' }-> 1 + s17 + dyade(@xs, z') :|: s17 >= 0, s17 <= inf, @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   mult(z, z') -{ 6 + 3*z' }-> s18 :|: s18 >= 0, s18 <= inf', z' >= 0, z >= 0
   mult#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   mult#1(z, z') -{ 8 + 3*@xs }-> 1 + s16 + s19 :|: s19 >= 0, s19 <= inf'', s16 >= 0, s16 <= 4 * (@x * z') + 1, @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   times(z, z') -{ 1 }-> s15 :|: s15 >= 0, s15 <= 4 * (z' * z) + 1, z >= 0, z' >= 0

Function symbols to be analyzed: {dyade,dyade#1}
Previous analysis results are:
  #pred: runtime: O(1) [0], size: O(n^1) [2 + z]
  #succ: runtime: O(1) [0], size: O(n^1) [2 + z]
  #add: runtime: O(1) [0], size: O(n^1) [2*z + z']
  #natmult: runtime: O(1) [0], size: O(n^2) [4 + 4*z + 4*z*z' + 4*z']
  #mult: runtime: O(1) [0], size: O(n^2) [1 + 4*z*z']
  times: runtime: O(1) [1], size: O(n^2) [1 + 4*z*z']
  mult#1: runtime: O(n^1) [5 + 3*z], size: INF
  mult: runtime: O(n^1) [6 + 3*z'], size: INF

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

(65) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

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

   #add(z, z') -{ 0 }-> s :|: s >= 0, s <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0
   #add(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 1 + (1 + (z' - 3)) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 1 + (1 + (1 + (z' - 2))) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> s10 :|: s8 >= 0, s8 <= 2 * (1 + (1 + (z - 4))) + z', s9 >= 0, s9 <= s8 + 2, s10 >= 0, s10 <= s9 + 2, z' >= 0, z - 4 >= 0
   #add(z, z') -{ 0 }-> s2 :|: s2 >= 0, s2 <= 1 + (1 + 0) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> s7 :|: s5 >= 0, s5 <= 2 * (1 + (1 + (z - 4))) + z', s6 >= 0, s6 <= s5 + 2, s7 >= 0, s7 <= s6 + 2, z - 4 >= 0, z' >= 0
   #add(z, z') -{ 0 }-> z' :|: z = 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' >= 0, v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, v0' >= 0, 0 = v0'
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, v0 >= 0, 1 + (1 + (z' - 3)) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, v0 >= 0, 1 + (1 + (1 + (z' - 2))) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, v0 >= 0, 1 + (1 + 0) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, 1 + (1 + 0) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + 0), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z - 3 >= 0, z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + (z' - 3)) :|: z = 1 + (1 + 0), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x)) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, @x >= 0, 1 + (1 + 0) = 1 + (1 + @x)
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + (z' - 2))) :|: z = 1 + (1 + 0), z' >= 0, z' - 2 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' - 1 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #mult(z, z') -{ 0 }-> 1 + s11 :|: s11 >= 0, s11 <= 4 * (z' - 1) + 4 * ((z' - 1) * (z - 1)) + 4 * (z - 1) + 4, z - 1 >= 0, z' - 1 >= 0
   #natmult(z, z') -{ 0 }-> s14 :|: s12 >= 0, s12 <= 4 * z' + 4 * (z' * (z - 2)) + 4 * (z - 2) + 4, s13 >= 0, s13 <= 2 * (1 + z') + s12, s14 >= 0, s14 <= 2 * (1 + z') + s13, z - 2 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> s3 :|: s3 >= 0, s3 <= 2 * (1 + z') + 0, z = 1 + 0, z' >= 0
   #natmult(z, z') -{ 0 }-> s4 :|: s4 >= 0, s4 <= 2 * (1 + z') + 0, z - 1 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z = 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #pred(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #pred(z) -{ 0 }-> 0 :|: z >= 0
   #pred(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #pred(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #pred(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   #succ(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #succ(z) -{ 0 }-> 0 :|: z >= 0
   #succ(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #succ(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #succ(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   dyade(z, z') -{ 1 }-> dyade#1(z, z') :|: z >= 0, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   dyade#1(z, z') -{ 7 + 3*z' }-> 1 + s17 + dyade(@xs, z') :|: s17 >= 0, s17 <= inf, @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   mult(z, z') -{ 6 + 3*z' }-> s18 :|: s18 >= 0, s18 <= inf', z' >= 0, z >= 0
   mult#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   mult#1(z, z') -{ 8 + 3*@xs }-> 1 + s16 + s19 :|: s19 >= 0, s19 <= inf'', s16 >= 0, s16 <= 4 * (@x * z') + 1, @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   times(z, z') -{ 1 }-> s15 :|: s15 >= 0, s15 <= 4 * (z' * z) + 1, z >= 0, z' >= 0

Function symbols to be analyzed: {dyade,dyade#1}
Previous analysis results are:
  #pred: runtime: O(1) [0], size: O(n^1) [2 + z]
  #succ: runtime: O(1) [0], size: O(n^1) [2 + z]
  #add: runtime: O(1) [0], size: O(n^1) [2*z + z']
  #natmult: runtime: O(1) [0], size: O(n^2) [4 + 4*z + 4*z*z' + 4*z']
  #mult: runtime: O(1) [0], size: O(n^2) [1 + 4*z*z']
  times: runtime: O(1) [1], size: O(n^2) [1 + 4*z*z']
  mult#1: runtime: O(n^1) [5 + 3*z], size: INF
  mult: runtime: O(n^1) [6 + 3*z'], size: INF
  dyade: runtime: ?, size: INF
  dyade#1: runtime: ?, size: INF

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

(67) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

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

   #add(z, z') -{ 0 }-> s :|: s >= 0, s <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0
   #add(z, z') -{ 0 }-> s' :|: s' >= 0, s' <= 1 + (1 + (z' - 3)) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> s'' :|: s'' >= 0, s'' <= 1 + (1 + (1 + (z' - 2))) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0
   #add(z, z') -{ 0 }-> s1 :|: s1 >= 0, s1 <= 0 + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> s10 :|: s8 >= 0, s8 <= 2 * (1 + (1 + (z - 4))) + z', s9 >= 0, s9 <= s8 + 2, s10 >= 0, s10 <= s9 + 2, z' >= 0, z - 4 >= 0
   #add(z, z') -{ 0 }-> s2 :|: s2 >= 0, s2 <= 1 + (1 + 0) + 2, z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> s7 :|: s5 >= 0, s5 <= 2 * (1 + (1 + (z - 4))) + z', s6 >= 0, s6 <= s5 + 2, s7 >= 0, s7 <= s6 + 2, z - 4 >= 0, z' >= 0
   #add(z, z') -{ 0 }-> z' :|: z = 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0, z' = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + 0), z' >= 0
   #add(z, z') -{ 0 }-> 0 :|: z - 3 >= 0, z' >= 0, v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, v0' >= 0, 0 = v0'
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, v0 >= 0, 1 + (1 + (z' - 3)) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, v0 >= 0, 1 + (1 + (1 + (z' - 2))) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), v0 >= 0, 0 = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, v0 >= 0, 1 + (1 + 0) = v0
   #add(z, z') -{ 0 }-> 0 :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, 1 + (1 + 0) = 1 + (1 + 0)
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + @x') :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + (1 + @x'))
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + 0), z' >= 0, z' = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z - 3 >= 0, z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + 0) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 1 + (1 + 0), 0 = 0
   #add(z, z') -{ 0 }-> 1 + (1 + (z' - 3)) :|: z = 1 + (1 + 0), z' >= 0, z' - 3 >= 0
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x)) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' = 0, @x >= 0, 1 + (1 + 0) = 1 + (1 + @x)
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 3 >= 0, @x' >= 0, 1 + (1 + (z' - 3)) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + @x')) :|: z = 1 + (1 + (1 + 0)), z' >= 0, z' - 2 >= 0, @x' >= 0, 1 + (1 + (1 + (z' - 2))) = 1 + (1 + @x')
   #add(z, z') -{ 0 }-> 1 + (1 + (1 + (z' - 2))) :|: z = 1 + (1 + 0), z' >= 0, z' - 2 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z = 0, z' - 1 >= 0
   #mult(z, z') -{ 0 }-> 0 :|: z - 1 >= 0, z' = 0
   #mult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #mult(z, z') -{ 0 }-> 1 + s11 :|: s11 >= 0, s11 <= 4 * (z' - 1) + 4 * ((z' - 1) * (z - 1)) + 4 * (z - 1) + 4, z - 1 >= 0, z' - 1 >= 0
   #natmult(z, z') -{ 0 }-> s14 :|: s12 >= 0, s12 <= 4 * z' + 4 * (z' * (z - 2)) + 4 * (z - 2) + 4, s13 >= 0, s13 <= 2 * (1 + z') + s12, s14 >= 0, s14 <= 2 * (1 + z') + s13, z - 2 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> s3 :|: s3 >= 0, s3 <= 2 * (1 + z') + 0, z = 1 + 0, z' >= 0
   #natmult(z, z') -{ 0 }-> s4 :|: s4 >= 0, s4 <= 2 * (1 + z') + 0, z - 1 >= 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z = 0, z' >= 0
   #natmult(z, z') -{ 0 }-> 0 :|: z >= 0, z' >= 0
   #pred(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #pred(z) -{ 0 }-> 0 :|: z >= 0
   #pred(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #pred(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #pred(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   #succ(z) -{ 0 }-> 0 :|: z = 1 + (1 + 0)
   #succ(z) -{ 0 }-> 0 :|: z >= 0
   #succ(z) -{ 0 }-> 1 + (1 + 0) :|: z = 0
   #succ(z) -{ 0 }-> 1 + (1 + (z - 3)) :|: z - 3 >= 0
   #succ(z) -{ 0 }-> 1 + (1 + (1 + (z - 2))) :|: z - 2 >= 0
   dyade(z, z') -{ 1 }-> dyade#1(z, z') :|: z >= 0, z' >= 0
   dyade#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   dyade#1(z, z') -{ 7 + 3*z' }-> 1 + s17 + dyade(@xs, z') :|: s17 >= 0, s17 <= inf, @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   mult(z, z') -{ 6 + 3*z' }-> s18 :|: s18 >= 0, s18 <= inf', z' >= 0, z >= 0
   mult#1(z, z') -{ 1 }-> 1 :|: z = 1, z' >= 0
   mult#1(z, z') -{ 8 + 3*@xs }-> 1 + s16 + s19 :|: s19 >= 0, s19 <= inf'', s16 >= 0, s16 <= 4 * (@x * z') + 1, @x >= 0, z = 1 + @x + @xs, z' >= 0, @xs >= 0
   times(z, z') -{ 1 }-> s15 :|: s15 >= 0, s15 <= 4 * (z' * z) + 1, z >= 0, z' >= 0

Function symbols to be analyzed: 
Previous analysis results are:
  #pred: runtime: O(1) [0], size: O(n^1) [2 + z]
  #succ: runtime: O(1) [0], size: O(n^1) [2 + z]
  #add: runtime: O(1) [0], size: O(n^1) [2*z + z']
  #natmult: runtime: O(1) [0], size: O(n^2) [4 + 4*z + 4*z*z' + 4*z']
  #mult: runtime: O(1) [0], size: O(n^2) [1 + 4*z*z']
  times: runtime: O(1) [1], size: O(n^2) [1 + 4*z*z']
  mult#1: runtime: O(n^1) [5 + 3*z], size: INF
  mult: runtime: O(n^1) [6 + 3*z'], size: INF
  dyade: runtime: O(n^2) [10 + 8*z + 3*z*z' + 3*z'], size: INF
  dyade#1: runtime: O(n^2) [18 + 8*z + 3*z*z' + 6*z'], size: INF

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

(69) FinalProof (FINISHED)
Computed overall runtime complexity
----------------------------------------

(70)
BOUNDS(1, n^2)

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

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

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

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


The TRS R consists of the following rules:

   *(@x, @y) -> #mult(@x, @y)
   dyade(@l1, @l2) -> dyade#1(@l1, @l2)
   dyade#1(::(@x, @xs), @l2) -> ::(mult(@x, @l2), dyade(@xs, @l2))
   dyade#1(nil, @l2) -> nil
   mult(@n, @l) -> mult#1(@l, @n)
   mult#1(::(@x, @xs), @n) -> ::(*(@n, @x), mult(@n, @xs))
   mult#1(nil, @n) -> nil

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

   #add(#0, @y) -> @y
   #add(#neg(#s(#0)), @y) -> #pred(@y)
   #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
   #add(#pos(#s(#0)), @y) -> #succ(@y)
   #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
   #mult(#0, #0) -> #0
   #mult(#0, #neg(@y)) -> #0
   #mult(#0, #pos(@y)) -> #0
   #mult(#neg(@x), #0) -> #0
   #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
   #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
   #mult(#pos(@x), #0) -> #0
   #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
   #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
   #natmult(#0, @y) -> #0
   #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y))
   #pred(#0) -> #neg(#s(#0))
   #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
   #pred(#pos(#s(#0))) -> #0
   #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
   #succ(#0) -> #pos(#s(#0))
   #succ(#neg(#s(#0))) -> #0
   #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
   #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))

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

(73) DecreasingLoopProof (LOWER BOUND(ID))
The following loop(s) give(s) rise to the lower bound Omega(n^1):

The rewrite sequence

dyade#1(::(@x, @xs), @l2) ->^+ ::(mult(@x, @l2), dyade#1(@xs, @l2))

gives rise to a decreasing loop by considering the right hand sides subterm at position [1].

The pumping substitution is [@xs / ::(@x, @xs)].

The result substitution is [ ].




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

(74)
Complex Obligation (BEST)

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

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

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


The TRS R consists of the following rules:

   *(@x, @y) -> #mult(@x, @y)
   dyade(@l1, @l2) -> dyade#1(@l1, @l2)
   dyade#1(::(@x, @xs), @l2) -> ::(mult(@x, @l2), dyade(@xs, @l2))
   dyade#1(nil, @l2) -> nil
   mult(@n, @l) -> mult#1(@l, @n)
   mult#1(::(@x, @xs), @n) -> ::(*(@n, @x), mult(@n, @xs))
   mult#1(nil, @n) -> nil

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

   #add(#0, @y) -> @y
   #add(#neg(#s(#0)), @y) -> #pred(@y)
   #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
   #add(#pos(#s(#0)), @y) -> #succ(@y)
   #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
   #mult(#0, #0) -> #0
   #mult(#0, #neg(@y)) -> #0
   #mult(#0, #pos(@y)) -> #0
   #mult(#neg(@x), #0) -> #0
   #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
   #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
   #mult(#pos(@x), #0) -> #0
   #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
   #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
   #natmult(#0, @y) -> #0
   #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y))
   #pred(#0) -> #neg(#s(#0))
   #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
   #pred(#pos(#s(#0))) -> #0
   #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
   #succ(#0) -> #pos(#s(#0))
   #succ(#neg(#s(#0))) -> #0
   #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
   #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))

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

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

(77)
BOUNDS(n^1, INF)

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

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

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


The TRS R consists of the following rules:

   *(@x, @y) -> #mult(@x, @y)
   dyade(@l1, @l2) -> dyade#1(@l1, @l2)
   dyade#1(::(@x, @xs), @l2) -> ::(mult(@x, @l2), dyade(@xs, @l2))
   dyade#1(nil, @l2) -> nil
   mult(@n, @l) -> mult#1(@l, @n)
   mult#1(::(@x, @xs), @n) -> ::(*(@n, @x), mult(@n, @xs))
   mult#1(nil, @n) -> nil

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

   #add(#0, @y) -> @y
   #add(#neg(#s(#0)), @y) -> #pred(@y)
   #add(#neg(#s(#s(@x))), @y) -> #pred(#add(#pos(#s(@x)), @y))
   #add(#pos(#s(#0)), @y) -> #succ(@y)
   #add(#pos(#s(#s(@x))), @y) -> #succ(#add(#pos(#s(@x)), @y))
   #mult(#0, #0) -> #0
   #mult(#0, #neg(@y)) -> #0
   #mult(#0, #pos(@y)) -> #0
   #mult(#neg(@x), #0) -> #0
   #mult(#neg(@x), #neg(@y)) -> #pos(#natmult(@x, @y))
   #mult(#neg(@x), #pos(@y)) -> #neg(#natmult(@x, @y))
   #mult(#pos(@x), #0) -> #0
   #mult(#pos(@x), #neg(@y)) -> #neg(#natmult(@x, @y))
   #mult(#pos(@x), #pos(@y)) -> #pos(#natmult(@x, @y))
   #natmult(#0, @y) -> #0
   #natmult(#s(@x), @y) -> #add(#pos(@y), #natmult(@x, @y))
   #pred(#0) -> #neg(#s(#0))
   #pred(#neg(#s(@x))) -> #neg(#s(#s(@x)))
   #pred(#pos(#s(#0))) -> #0
   #pred(#pos(#s(#s(@x)))) -> #pos(#s(@x))
   #succ(#0) -> #pos(#s(#0))
   #succ(#neg(#s(#0))) -> #0
   #succ(#neg(#s(#s(@x)))) -> #neg(#s(@x))
   #succ(#pos(#s(@x))) -> #pos(#s(#s(@x)))

Rewrite Strategy: INNERMOST