/export/starexec/sandbox2/solver/bin/starexec_run_rcdcRelativeAlsoLower /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: 794c25de1cacf0d048858bcd21c9a779e1221865 marcel 20200619 unpublished dirty


The Derivational Complexity (full) of the given DCpxTrs could be proven to be BOUNDS(n^1, n^2).

(0) DCpxTrs
(1) DerivationalComplexityToRuntimeComplexityProof [BOTH BOUNDS(ID, ID), 0 ms]
(2) CpxRelTRS
(3) SInnermostTerminationProof [BOTH CONCRETE BOUNDS(ID, ID), 47 ms]
(4) CpxRelTRS
(5) RcToIrcProof [BOTH BOUNDS(ID, ID), 0 ms]
(6) CpxRelTRS
    (7) RelTrsToWeightedTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (8) CpxWeightedTrs
    (9) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
    (10) CpxTypedWeightedTrs
    (11) CompletionProof [UPPER BOUND(ID), 0 ms]
    (12) CpxTypedWeightedCompleteTrs
    (13) NarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (14) CpxTypedWeightedCompleteTrs
    (15) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
    (16) CpxRNTS
    (17) SimplificationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (18) CpxRNTS
    (19) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 0 ms]
    (20) CpxRNTS
    (21) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (22) CpxRNTS
    (23) IntTrsBoundProof [UPPER BOUND(ID), 76 ms]
    (24) CpxRNTS
    (25) IntTrsBoundProof [UPPER BOUND(ID), 14 ms]
    (26) CpxRNTS
    (27) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (28) CpxRNTS
    (29) IntTrsBoundProof [UPPER BOUND(ID), 521 ms]
    (30) CpxRNTS
    (31) IntTrsBoundProof [UPPER BOUND(ID), 171 ms]
    (32) CpxRNTS
    (33) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (34) CpxRNTS
    (35) IntTrsBoundProof [UPPER BOUND(ID), 651 ms]
    (36) CpxRNTS
    (37) IntTrsBoundProof [UPPER BOUND(ID), 407 ms]
    (38) CpxRNTS
    (39) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (40) CpxRNTS
    (41) IntTrsBoundProof [UPPER BOUND(ID), 281 ms]
    (42) CpxRNTS
    (43) IntTrsBoundProof [UPPER BOUND(ID), 7 ms]
    (44) CpxRNTS
    (45) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (46) CpxRNTS
    (47) IntTrsBoundProof [UPPER BOUND(ID), 305 ms]
    (48) CpxRNTS
    (49) IntTrsBoundProof [UPPER BOUND(ID), 45 ms]
    (50) CpxRNTS
    (51) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
    (52) CpxRNTS
    (53) IntTrsBoundProof [UPPER BOUND(ID), 209 ms]
    (54) CpxRNTS
    (55) IntTrsBoundProof [UPPER BOUND(ID), 0 ms]
    (56) CpxRNTS
    (57) FinalProof [FINISHED, 0 ms]
    (58) BOUNDS(1, n^2)
(59) RenamingProof [BOTH BOUNDS(ID, ID), 0 ms]
(60) CpxRelTRS
    (61) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
    (62) typed CpxTrs
    (63) OrderProof [LOWER BOUND(ID), 0 ms]
    (64) typed CpxTrs
    (65) RewriteLemmaProof [LOWER BOUND(ID), 253 ms]
    (66) BEST
        (67) proven lower bound
            (68) LowerBoundPropagationProof [FINISHED, 0 ms]
            (69) BOUNDS(n^1, INF)
        (70) typed CpxTrs
            (71) RewriteLemmaProof [LOWER BOUND(ID), 37 ms]
            (72) BOUNDS(1, INF)


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

(0)
Obligation:
The Derivational Complexity (full) of the given DCpxTrs could be proven to be BOUNDS(n^1, n^2).


The TRS R consists of the following rules:

   g(s(x)) -> f(x)
   f(0) -> s(0)
   f(s(x)) -> s(s(g(x)))
   g(0) -> 0

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

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

   encArg(s(x_1)) -> s(encArg(x_1))
   encArg(0) -> 0
   encArg(cons_g(x_1)) -> g(encArg(x_1))
   encArg(cons_f(x_1)) -> f(encArg(x_1))
   encode_g(x_1) -> g(encArg(x_1))
   encode_s(x_1) -> s(encArg(x_1))
   encode_f(x_1) -> f(encArg(x_1))
   encode_0 -> 0


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

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


The TRS R consists of the following rules:

   g(s(x)) -> f(x)
   f(0) -> s(0)
   f(s(x)) -> s(s(g(x)))
   g(0) -> 0

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

   encArg(s(x_1)) -> s(encArg(x_1))
   encArg(0) -> 0
   encArg(cons_g(x_1)) -> g(encArg(x_1))
   encArg(cons_f(x_1)) -> f(encArg(x_1))
   encode_g(x_1) -> g(encArg(x_1))
   encode_s(x_1) -> s(encArg(x_1))
   encode_f(x_1) -> f(encArg(x_1))
   encode_0 -> 0

Rewrite Strategy: FULL
----------------------------------------

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

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


The TRS R consists of the following rules:

   g(s(x)) -> f(x)
   f(0) -> s(0)
   f(s(x)) -> s(s(g(x)))
   g(0) -> 0

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

   encArg(s(x_1)) -> s(encArg(x_1))
   encArg(0) -> 0
   encArg(cons_g(x_1)) -> g(encArg(x_1))
   encArg(cons_f(x_1)) -> f(encArg(x_1))
   encode_g(x_1) -> g(encArg(x_1))
   encode_s(x_1) -> s(encArg(x_1))
   encode_f(x_1) -> f(encArg(x_1))
   encode_0 -> 0

Rewrite Strategy: FULL
----------------------------------------

(5) RcToIrcProof (BOTH BOUNDS(ID, ID))
Converted rc-obligation to irc-obligation.

As the TRS is a non-duplicating overlay system, we have rc = irc.
----------------------------------------

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


The TRS R consists of the following rules:

   g(s(x)) -> f(x)
   f(0) -> s(0)
   f(s(x)) -> s(s(g(x)))
   g(0) -> 0

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

   encArg(s(x_1)) -> s(encArg(x_1))
   encArg(0) -> 0
   encArg(cons_g(x_1)) -> g(encArg(x_1))
   encArg(cons_f(x_1)) -> f(encArg(x_1))
   encode_g(x_1) -> g(encArg(x_1))
   encode_s(x_1) -> s(encArg(x_1))
   encode_f(x_1) -> f(encArg(x_1))
   encode_0 -> 0

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

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

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

   g(s(x)) -> f(x) [1]
   f(0) -> s(0) [1]
   f(s(x)) -> s(s(g(x))) [1]
   g(0) -> 0 [1]
   encArg(s(x_1)) -> s(encArg(x_1)) [0]
   encArg(0) -> 0 [0]
   encArg(cons_g(x_1)) -> g(encArg(x_1)) [0]
   encArg(cons_f(x_1)) -> f(encArg(x_1)) [0]
   encode_g(x_1) -> g(encArg(x_1)) [0]
   encode_s(x_1) -> s(encArg(x_1)) [0]
   encode_f(x_1) -> f(encArg(x_1)) [0]
   encode_0 -> 0 [0]

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

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

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

   g(s(x)) -> f(x) [1]
   f(0) -> s(0) [1]
   f(s(x)) -> s(s(g(x))) [1]
   g(0) -> 0 [1]
   encArg(s(x_1)) -> s(encArg(x_1)) [0]
   encArg(0) -> 0 [0]
   encArg(cons_g(x_1)) -> g(encArg(x_1)) [0]
   encArg(cons_f(x_1)) -> f(encArg(x_1)) [0]
   encode_g(x_1) -> g(encArg(x_1)) [0]
   encode_s(x_1) -> s(encArg(x_1)) [0]
   encode_f(x_1) -> f(encArg(x_1)) [0]
   encode_0 -> 0 [0]

The TRS has the following type information:
g :: s:0:cons_g:cons_f -> s:0:cons_g:cons_f
s :: s:0:cons_g:cons_f -> s:0:cons_g:cons_f
f :: s:0:cons_g:cons_f -> s:0:cons_g:cons_f
0 :: s:0:cons_g:cons_f
encArg :: s:0:cons_g:cons_f -> s:0:cons_g:cons_f
cons_g :: s:0:cons_g:cons_f -> s:0:cons_g:cons_f
cons_f :: s:0:cons_g:cons_f -> s:0:cons_g:cons_f
encode_g :: s:0:cons_g:cons_f -> s:0:cons_g:cons_f
encode_s :: s:0:cons_g:cons_f -> s:0:cons_g:cons_f
encode_f :: s:0:cons_g:cons_f -> s:0:cons_g:cons_f
encode_0 :: s:0:cons_g:cons_f

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

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

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

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

(c) The following functions are completely defined:

   g_1
   f_1
   encArg_1
   encode_g_1
   encode_s_1
   encode_f_1
   encode_0

Due to the following rules being added:

   encArg(v0) -> 0 [0]
   encode_g(v0) -> 0 [0]
   encode_s(v0) -> 0 [0]
   encode_f(v0) -> 0 [0]
   encode_0 -> 0 [0]
   g(v0) -> 0 [0]
   f(v0) -> 0 [0]

And the following fresh constants: none

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

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

   g(s(x)) -> f(x) [1]
   f(0) -> s(0) [1]
   f(s(x)) -> s(s(g(x))) [1]
   g(0) -> 0 [1]
   encArg(s(x_1)) -> s(encArg(x_1)) [0]
   encArg(0) -> 0 [0]
   encArg(cons_g(x_1)) -> g(encArg(x_1)) [0]
   encArg(cons_f(x_1)) -> f(encArg(x_1)) [0]
   encode_g(x_1) -> g(encArg(x_1)) [0]
   encode_s(x_1) -> s(encArg(x_1)) [0]
   encode_f(x_1) -> f(encArg(x_1)) [0]
   encode_0 -> 0 [0]
   encArg(v0) -> 0 [0]
   encode_g(v0) -> 0 [0]
   encode_s(v0) -> 0 [0]
   encode_f(v0) -> 0 [0]
   encode_0 -> 0 [0]
   g(v0) -> 0 [0]
   f(v0) -> 0 [0]

The TRS has the following type information:
g :: s:0:cons_g:cons_f -> s:0:cons_g:cons_f
s :: s:0:cons_g:cons_f -> s:0:cons_g:cons_f
f :: s:0:cons_g:cons_f -> s:0:cons_g:cons_f
0 :: s:0:cons_g:cons_f
encArg :: s:0:cons_g:cons_f -> s:0:cons_g:cons_f
cons_g :: s:0:cons_g:cons_f -> s:0:cons_g:cons_f
cons_f :: s:0:cons_g:cons_f -> s:0:cons_g:cons_f
encode_g :: s:0:cons_g:cons_f -> s:0:cons_g:cons_f
encode_s :: s:0:cons_g:cons_f -> s:0:cons_g:cons_f
encode_f :: s:0:cons_g:cons_f -> s:0:cons_g:cons_f
encode_0 :: s:0:cons_g:cons_f

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

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

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

   g(s(x)) -> f(x) [1]
   f(0) -> s(0) [1]
   f(s(x)) -> s(s(g(x))) [1]
   g(0) -> 0 [1]
   encArg(s(x_1)) -> s(encArg(x_1)) [0]
   encArg(0) -> 0 [0]
   encArg(cons_g(s(x_1'))) -> g(s(encArg(x_1'))) [0]
   encArg(cons_g(0)) -> g(0) [0]
   encArg(cons_g(cons_g(x_1''))) -> g(g(encArg(x_1''))) [0]
   encArg(cons_g(cons_f(x_11))) -> g(f(encArg(x_11))) [0]
   encArg(cons_g(x_1)) -> g(0) [0]
   encArg(cons_f(s(x_12))) -> f(s(encArg(x_12))) [0]
   encArg(cons_f(0)) -> f(0) [0]
   encArg(cons_f(cons_g(x_13))) -> f(g(encArg(x_13))) [0]
   encArg(cons_f(cons_f(x_14))) -> f(f(encArg(x_14))) [0]
   encArg(cons_f(x_1)) -> f(0) [0]
   encode_g(s(x_15)) -> g(s(encArg(x_15))) [0]
   encode_g(0) -> g(0) [0]
   encode_g(cons_g(x_16)) -> g(g(encArg(x_16))) [0]
   encode_g(cons_f(x_17)) -> g(f(encArg(x_17))) [0]
   encode_g(x_1) -> g(0) [0]
   encode_s(x_1) -> s(encArg(x_1)) [0]
   encode_f(s(x_18)) -> f(s(encArg(x_18))) [0]
   encode_f(0) -> f(0) [0]
   encode_f(cons_g(x_19)) -> f(g(encArg(x_19))) [0]
   encode_f(cons_f(x_110)) -> f(f(encArg(x_110))) [0]
   encode_f(x_1) -> f(0) [0]
   encode_0 -> 0 [0]
   encArg(v0) -> 0 [0]
   encode_g(v0) -> 0 [0]
   encode_s(v0) -> 0 [0]
   encode_f(v0) -> 0 [0]
   encode_0 -> 0 [0]
   g(v0) -> 0 [0]
   f(v0) -> 0 [0]

The TRS has the following type information:
g :: s:0:cons_g:cons_f -> s:0:cons_g:cons_f
s :: s:0:cons_g:cons_f -> s:0:cons_g:cons_f
f :: s:0:cons_g:cons_f -> s:0:cons_g:cons_f
0 :: s:0:cons_g:cons_f
encArg :: s:0:cons_g:cons_f -> s:0:cons_g:cons_f
cons_g :: s:0:cons_g:cons_f -> s:0:cons_g:cons_f
cons_f :: s:0:cons_g:cons_f -> s:0:cons_g:cons_f
encode_g :: s:0:cons_g:cons_f -> s:0:cons_g:cons_f
encode_s :: s:0:cons_g:cons_f -> s:0:cons_g:cons_f
encode_f :: s:0:cons_g:cons_f -> s:0:cons_g:cons_f
encode_0 :: s:0:cons_g:cons_f

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

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

   0 => 0

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

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

   encArg(z) -{ 0 }-> g(g(encArg(x_1''))) :|: z = 1 + (1 + x_1''), x_1'' >= 0
   encArg(z) -{ 0 }-> g(f(encArg(x_11))) :|: x_11 >= 0, z = 1 + (1 + x_11)
   encArg(z) -{ 0 }-> g(0) :|: z = 1 + 0
   encArg(z) -{ 0 }-> g(0) :|: z = 1 + x_1, x_1 >= 0
   encArg(z) -{ 0 }-> g(1 + encArg(x_1')) :|: z = 1 + (1 + x_1'), x_1' >= 0
   encArg(z) -{ 0 }-> f(g(encArg(x_13))) :|: z = 1 + (1 + x_13), x_13 >= 0
   encArg(z) -{ 0 }-> f(f(encArg(x_14))) :|: x_14 >= 0, z = 1 + (1 + x_14)
   encArg(z) -{ 0 }-> f(0) :|: z = 1 + 0
   encArg(z) -{ 0 }-> f(0) :|: z = 1 + x_1, x_1 >= 0
   encArg(z) -{ 0 }-> f(1 + encArg(x_12)) :|: z = 1 + (1 + x_12), x_12 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   encArg(z) -{ 0 }-> 1 + encArg(x_1) :|: z = 1 + x_1, x_1 >= 0
   encode_0 -{ 0 }-> 0 :|: 
   encode_f(z) -{ 0 }-> f(g(encArg(x_19))) :|: z = 1 + x_19, x_19 >= 0
   encode_f(z) -{ 0 }-> f(f(encArg(x_110))) :|: z = 1 + x_110, x_110 >= 0
   encode_f(z) -{ 0 }-> f(0) :|: z = 0
   encode_f(z) -{ 0 }-> f(0) :|: x_1 >= 0, z = x_1
   encode_f(z) -{ 0 }-> f(1 + encArg(x_18)) :|: z = 1 + x_18, x_18 >= 0
   encode_f(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   encode_g(z) -{ 0 }-> g(g(encArg(x_16))) :|: z = 1 + x_16, x_16 >= 0
   encode_g(z) -{ 0 }-> g(f(encArg(x_17))) :|: x_17 >= 0, z = 1 + x_17
   encode_g(z) -{ 0 }-> g(0) :|: z = 0
   encode_g(z) -{ 0 }-> g(0) :|: x_1 >= 0, z = x_1
   encode_g(z) -{ 0 }-> g(1 + encArg(x_15)) :|: x_15 >= 0, z = 1 + x_15
   encode_g(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   encode_s(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   encode_s(z) -{ 0 }-> 1 + encArg(x_1) :|: x_1 >= 0, z = x_1
   f(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   f(z) -{ 1 }-> 1 + 0 :|: z = 0
   f(z) -{ 1 }-> 1 + (1 + g(x)) :|: x >= 0, z = 1 + x
   g(z) -{ 1 }-> f(x) :|: x >= 0, z = 1 + x
   g(z) -{ 1 }-> 0 :|: z = 0
   g(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0


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

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

   encArg(z) -{ 0 }-> g(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> g(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> g(0) :|: z = 1 + 0
   encArg(z) -{ 0 }-> g(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> g(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(0) :|: z = 1 + 0
   encArg(z) -{ 0 }-> f(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> f(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_0 -{ 0 }-> 0 :|: 
   encode_f(z) -{ 0 }-> f(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> f(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> f(0) :|: z = 0
   encode_f(z) -{ 0 }-> f(0) :|: z >= 0
   encode_f(z) -{ 0 }-> f(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 0 }-> g(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_g(z) -{ 0 }-> g(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_g(z) -{ 0 }-> g(0) :|: z = 0
   encode_g(z) -{ 0 }-> g(0) :|: z >= 0
   encode_g(z) -{ 0 }-> g(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 0 }-> 0 :|: z >= 0
   f(z) -{ 1 }-> 1 + 0 :|: z = 0
   f(z) -{ 1 }-> 1 + (1 + g(z - 1)) :|: z - 1 >= 0
   g(z) -{ 1 }-> f(z - 1) :|: z - 1 >= 0
   g(z) -{ 1 }-> 0 :|: z = 0
   g(z) -{ 0 }-> 0 :|: z >= 0


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

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

   { encode_0 }
   { f, g }
   { encArg }
   { encode_f }
   { encode_g }
   { encode_s }

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

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

   encArg(z) -{ 0 }-> g(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> g(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> g(0) :|: z = 1 + 0
   encArg(z) -{ 0 }-> g(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> g(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(0) :|: z = 1 + 0
   encArg(z) -{ 0 }-> f(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> f(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_0 -{ 0 }-> 0 :|: 
   encode_f(z) -{ 0 }-> f(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> f(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> f(0) :|: z = 0
   encode_f(z) -{ 0 }-> f(0) :|: z >= 0
   encode_f(z) -{ 0 }-> f(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 0 }-> g(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_g(z) -{ 0 }-> g(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_g(z) -{ 0 }-> g(0) :|: z = 0
   encode_g(z) -{ 0 }-> g(0) :|: z >= 0
   encode_g(z) -{ 0 }-> g(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 0 }-> 0 :|: z >= 0
   f(z) -{ 1 }-> 1 + 0 :|: z = 0
   f(z) -{ 1 }-> 1 + (1 + g(z - 1)) :|: z - 1 >= 0
   g(z) -{ 1 }-> f(z - 1) :|: z - 1 >= 0
   g(z) -{ 1 }-> 0 :|: z = 0
   g(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {encode_0}, {f,g}, {encArg}, {encode_f}, {encode_g}, {encode_s}

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

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

   encArg(z) -{ 0 }-> g(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> g(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> g(0) :|: z = 1 + 0
   encArg(z) -{ 0 }-> g(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> g(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(0) :|: z = 1 + 0
   encArg(z) -{ 0 }-> f(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> f(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_0 -{ 0 }-> 0 :|: 
   encode_f(z) -{ 0 }-> f(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> f(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> f(0) :|: z = 0
   encode_f(z) -{ 0 }-> f(0) :|: z >= 0
   encode_f(z) -{ 0 }-> f(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 0 }-> g(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_g(z) -{ 0 }-> g(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_g(z) -{ 0 }-> g(0) :|: z = 0
   encode_g(z) -{ 0 }-> g(0) :|: z >= 0
   encode_g(z) -{ 0 }-> g(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 0 }-> 0 :|: z >= 0
   f(z) -{ 1 }-> 1 + 0 :|: z = 0
   f(z) -{ 1 }-> 1 + (1 + g(z - 1)) :|: z - 1 >= 0
   g(z) -{ 1 }-> f(z - 1) :|: z - 1 >= 0
   g(z) -{ 1 }-> 0 :|: z = 0
   g(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {encode_0}, {f,g}, {encArg}, {encode_f}, {encode_g}, {encode_s}

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

(23) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   encArg(z) -{ 0 }-> g(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> g(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> g(0) :|: z = 1 + 0
   encArg(z) -{ 0 }-> g(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> g(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(0) :|: z = 1 + 0
   encArg(z) -{ 0 }-> f(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> f(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_0 -{ 0 }-> 0 :|: 
   encode_f(z) -{ 0 }-> f(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> f(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> f(0) :|: z = 0
   encode_f(z) -{ 0 }-> f(0) :|: z >= 0
   encode_f(z) -{ 0 }-> f(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 0 }-> g(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_g(z) -{ 0 }-> g(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_g(z) -{ 0 }-> g(0) :|: z = 0
   encode_g(z) -{ 0 }-> g(0) :|: z >= 0
   encode_g(z) -{ 0 }-> g(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 0 }-> 0 :|: z >= 0
   f(z) -{ 1 }-> 1 + 0 :|: z = 0
   f(z) -{ 1 }-> 1 + (1 + g(z - 1)) :|: z - 1 >= 0
   g(z) -{ 1 }-> f(z - 1) :|: z - 1 >= 0
   g(z) -{ 1 }-> 0 :|: z = 0
   g(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {encode_0}, {f,g}, {encArg}, {encode_f}, {encode_g}, {encode_s}
Previous analysis results are:
  encode_0: runtime: ?, size: O(1) [0]

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

(25) IntTrsBoundProof (UPPER BOUND(ID))

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

   encArg(z) -{ 0 }-> g(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> g(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> g(0) :|: z = 1 + 0
   encArg(z) -{ 0 }-> g(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> g(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(0) :|: z = 1 + 0
   encArg(z) -{ 0 }-> f(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> f(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_0 -{ 0 }-> 0 :|: 
   encode_f(z) -{ 0 }-> f(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> f(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> f(0) :|: z = 0
   encode_f(z) -{ 0 }-> f(0) :|: z >= 0
   encode_f(z) -{ 0 }-> f(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 0 }-> g(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_g(z) -{ 0 }-> g(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_g(z) -{ 0 }-> g(0) :|: z = 0
   encode_g(z) -{ 0 }-> g(0) :|: z >= 0
   encode_g(z) -{ 0 }-> g(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 0 }-> 0 :|: z >= 0
   f(z) -{ 1 }-> 1 + 0 :|: z = 0
   f(z) -{ 1 }-> 1 + (1 + g(z - 1)) :|: z - 1 >= 0
   g(z) -{ 1 }-> f(z - 1) :|: z - 1 >= 0
   g(z) -{ 1 }-> 0 :|: z = 0
   g(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {f,g}, {encArg}, {encode_f}, {encode_g}, {encode_s}
Previous analysis results are:
  encode_0: runtime: O(1) [0], size: O(1) [0]

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

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

   encArg(z) -{ 0 }-> g(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> g(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> g(0) :|: z = 1 + 0
   encArg(z) -{ 0 }-> g(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> g(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(0) :|: z = 1 + 0
   encArg(z) -{ 0 }-> f(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> f(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_0 -{ 0 }-> 0 :|: 
   encode_f(z) -{ 0 }-> f(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> f(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> f(0) :|: z = 0
   encode_f(z) -{ 0 }-> f(0) :|: z >= 0
   encode_f(z) -{ 0 }-> f(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 0 }-> g(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_g(z) -{ 0 }-> g(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_g(z) -{ 0 }-> g(0) :|: z = 0
   encode_g(z) -{ 0 }-> g(0) :|: z >= 0
   encode_g(z) -{ 0 }-> g(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 0 }-> 0 :|: z >= 0
   f(z) -{ 1 }-> 1 + 0 :|: z = 0
   f(z) -{ 1 }-> 1 + (1 + g(z - 1)) :|: z - 1 >= 0
   g(z) -{ 1 }-> f(z - 1) :|: z - 1 >= 0
   g(z) -{ 1 }-> 0 :|: z = 0
   g(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {f,g}, {encArg}, {encode_f}, {encode_g}, {encode_s}
Previous analysis results are:
  encode_0: runtime: O(1) [0], size: O(1) [0]

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

(29) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

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

   encArg(z) -{ 0 }-> g(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> g(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> g(0) :|: z = 1 + 0
   encArg(z) -{ 0 }-> g(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> g(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(0) :|: z = 1 + 0
   encArg(z) -{ 0 }-> f(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> f(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_0 -{ 0 }-> 0 :|: 
   encode_f(z) -{ 0 }-> f(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> f(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> f(0) :|: z = 0
   encode_f(z) -{ 0 }-> f(0) :|: z >= 0
   encode_f(z) -{ 0 }-> f(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 0 }-> g(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_g(z) -{ 0 }-> g(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_g(z) -{ 0 }-> g(0) :|: z = 0
   encode_g(z) -{ 0 }-> g(0) :|: z >= 0
   encode_g(z) -{ 0 }-> g(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 0 }-> 0 :|: z >= 0
   f(z) -{ 1 }-> 1 + 0 :|: z = 0
   f(z) -{ 1 }-> 1 + (1 + g(z - 1)) :|: z - 1 >= 0
   g(z) -{ 1 }-> f(z - 1) :|: z - 1 >= 0
   g(z) -{ 1 }-> 0 :|: z = 0
   g(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {f,g}, {encArg}, {encode_f}, {encode_g}, {encode_s}
Previous analysis results are:
  encode_0: runtime: O(1) [0], size: O(1) [0]
  f: runtime: ?, size: O(n^1) [1 + z]
  g: runtime: ?, size: O(n^1) [z]

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

(31) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

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

   encArg(z) -{ 0 }-> g(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> g(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> g(0) :|: z = 1 + 0
   encArg(z) -{ 0 }-> g(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> g(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(0) :|: z = 1 + 0
   encArg(z) -{ 0 }-> f(0) :|: z - 1 >= 0
   encArg(z) -{ 0 }-> f(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_0 -{ 0 }-> 0 :|: 
   encode_f(z) -{ 0 }-> f(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> f(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> f(0) :|: z = 0
   encode_f(z) -{ 0 }-> f(0) :|: z >= 0
   encode_f(z) -{ 0 }-> f(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 0 }-> g(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_g(z) -{ 0 }-> g(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_g(z) -{ 0 }-> g(0) :|: z = 0
   encode_g(z) -{ 0 }-> g(0) :|: z >= 0
   encode_g(z) -{ 0 }-> g(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 0 }-> 0 :|: z >= 0
   f(z) -{ 1 }-> 1 + 0 :|: z = 0
   f(z) -{ 1 }-> 1 + (1 + g(z - 1)) :|: z - 1 >= 0
   g(z) -{ 1 }-> f(z - 1) :|: z - 1 >= 0
   g(z) -{ 1 }-> 0 :|: z = 0
   g(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {encArg}, {encode_f}, {encode_g}, {encode_s}
Previous analysis results are:
  encode_0: runtime: O(1) [0], size: O(1) [0]
  f: runtime: O(n^1) [2 + 2*z], size: O(n^1) [1 + z]
  g: runtime: O(n^1) [1 + 2*z], size: O(n^1) [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:

   encArg(z) -{ 1 }-> s'' :|: s'' >= 0, s'' <= 0, z = 1 + 0
   encArg(z) -{ 1 }-> s1 :|: s1 >= 0, s1 <= 0, z - 1 >= 0
   encArg(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 0 + 1, z = 1 + 0
   encArg(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 1, z - 1 >= 0
   encArg(z) -{ 0 }-> g(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> g(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> g(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_0 -{ 0 }-> 0 :|: 
   encode_f(z) -{ 2 }-> s6 :|: s6 >= 0, s6 <= 0 + 1, z = 0
   encode_f(z) -{ 2 }-> s7 :|: s7 >= 0, s7 <= 0 + 1, z >= 0
   encode_f(z) -{ 0 }-> f(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> f(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> f(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 1 }-> s4 :|: s4 >= 0, s4 <= 0, z = 0
   encode_g(z) -{ 1 }-> s5 :|: s5 >= 0, s5 <= 0, z >= 0
   encode_g(z) -{ 0 }-> g(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_g(z) -{ 0 }-> g(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_g(z) -{ 0 }-> g(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 0 }-> 0 :|: z >= 0
   f(z) -{ 1 }-> 1 + 0 :|: z = 0
   f(z) -{ 2*z }-> 1 + (1 + s') :|: s' >= 0, s' <= z - 1, z - 1 >= 0
   g(z) -{ 1 + 2*z }-> s :|: s >= 0, s <= z - 1 + 1, z - 1 >= 0
   g(z) -{ 1 }-> 0 :|: z = 0
   g(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {encArg}, {encode_f}, {encode_g}, {encode_s}
Previous analysis results are:
  encode_0: runtime: O(1) [0], size: O(1) [0]
  f: runtime: O(n^1) [2 + 2*z], size: O(n^1) [1 + z]
  g: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z]

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

(35) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   encArg(z) -{ 1 }-> s'' :|: s'' >= 0, s'' <= 0, z = 1 + 0
   encArg(z) -{ 1 }-> s1 :|: s1 >= 0, s1 <= 0, z - 1 >= 0
   encArg(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 0 + 1, z = 1 + 0
   encArg(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 1, z - 1 >= 0
   encArg(z) -{ 0 }-> g(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> g(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> g(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_0 -{ 0 }-> 0 :|: 
   encode_f(z) -{ 2 }-> s6 :|: s6 >= 0, s6 <= 0 + 1, z = 0
   encode_f(z) -{ 2 }-> s7 :|: s7 >= 0, s7 <= 0 + 1, z >= 0
   encode_f(z) -{ 0 }-> f(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> f(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> f(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 1 }-> s4 :|: s4 >= 0, s4 <= 0, z = 0
   encode_g(z) -{ 1 }-> s5 :|: s5 >= 0, s5 <= 0, z >= 0
   encode_g(z) -{ 0 }-> g(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_g(z) -{ 0 }-> g(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_g(z) -{ 0 }-> g(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 0 }-> 0 :|: z >= 0
   f(z) -{ 1 }-> 1 + 0 :|: z = 0
   f(z) -{ 2*z }-> 1 + (1 + s') :|: s' >= 0, s' <= z - 1, z - 1 >= 0
   g(z) -{ 1 + 2*z }-> s :|: s >= 0, s <= z - 1 + 1, z - 1 >= 0
   g(z) -{ 1 }-> 0 :|: z = 0
   g(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {encArg}, {encode_f}, {encode_g}, {encode_s}
Previous analysis results are:
  encode_0: runtime: O(1) [0], size: O(1) [0]
  f: runtime: O(n^1) [2 + 2*z], size: O(n^1) [1 + z]
  g: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z]
  encArg: runtime: ?, size: O(n^1) [z]

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

(37) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   encArg(z) -{ 1 }-> s'' :|: s'' >= 0, s'' <= 0, z = 1 + 0
   encArg(z) -{ 1 }-> s1 :|: s1 >= 0, s1 <= 0, z - 1 >= 0
   encArg(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 0 + 1, z = 1 + 0
   encArg(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 1, z - 1 >= 0
   encArg(z) -{ 0 }-> g(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> g(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> g(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(g(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(f(encArg(z - 2))) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> f(1 + encArg(z - 2)) :|: z - 2 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 0 }-> 1 + encArg(z - 1) :|: z - 1 >= 0
   encode_0 -{ 0 }-> 0 :|: 
   encode_f(z) -{ 2 }-> s6 :|: s6 >= 0, s6 <= 0 + 1, z = 0
   encode_f(z) -{ 2 }-> s7 :|: s7 >= 0, s7 <= 0 + 1, z >= 0
   encode_f(z) -{ 0 }-> f(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> f(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> f(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 1 }-> s4 :|: s4 >= 0, s4 <= 0, z = 0
   encode_g(z) -{ 1 }-> s5 :|: s5 >= 0, s5 <= 0, z >= 0
   encode_g(z) -{ 0 }-> g(g(encArg(z - 1))) :|: z - 1 >= 0
   encode_g(z) -{ 0 }-> g(f(encArg(z - 1))) :|: z - 1 >= 0
   encode_g(z) -{ 0 }-> g(1 + encArg(z - 1)) :|: z - 1 >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 0 }-> 1 + encArg(z) :|: z >= 0
   f(z) -{ 0 }-> 0 :|: z >= 0
   f(z) -{ 1 }-> 1 + 0 :|: z = 0
   f(z) -{ 2*z }-> 1 + (1 + s') :|: s' >= 0, s' <= z - 1, z - 1 >= 0
   g(z) -{ 1 + 2*z }-> s :|: s >= 0, s <= z - 1 + 1, z - 1 >= 0
   g(z) -{ 1 }-> 0 :|: z = 0
   g(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {encode_f}, {encode_g}, {encode_s}
Previous analysis results are:
  encode_0: runtime: O(1) [0], size: O(1) [0]
  f: runtime: O(n^1) [2 + 2*z], size: O(n^1) [1 + z]
  g: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z]
  encArg: runtime: O(n^2) [6 + 20*z^2], size: O(n^1) [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:

   encArg(z) -{ 1 }-> s'' :|: s'' >= 0, s'' <= 0, z = 1 + 0
   encArg(z) -{ 1 }-> s1 :|: s1 >= 0, s1 <= 0, z - 1 >= 0
   encArg(z) -{ 89 + 2*s9 + -80*z + 20*z^2 }-> s10 :|: s9 >= 0, s9 <= z - 2, s10 >= 0, s10 <= 1 + s9, z - 2 >= 0
   encArg(z) -{ 88 + 2*s11 + 2*s12 + -80*z + 20*z^2 }-> s13 :|: s11 >= 0, s11 <= z - 2, s12 >= 0, s12 <= s11, s13 >= 0, s13 <= s12, z - 2 >= 0
   encArg(z) -{ 89 + 2*s14 + 2*s15 + -80*z + 20*z^2 }-> s16 :|: s14 >= 0, s14 <= z - 2, s15 >= 0, s15 <= s14 + 1, s16 >= 0, s16 <= s15, z - 2 >= 0
   encArg(z) -{ 90 + 2*s17 + -80*z + 20*z^2 }-> s18 :|: s17 >= 0, s17 <= z - 2, s18 >= 0, s18 <= 1 + s17 + 1, z - 2 >= 0
   encArg(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 0 + 1, z = 1 + 0
   encArg(z) -{ 89 + 2*s19 + 2*s20 + -80*z + 20*z^2 }-> s21 :|: s19 >= 0, s19 <= z - 2, s20 >= 0, s20 <= s19, s21 >= 0, s21 <= s20 + 1, z - 2 >= 0
   encArg(z) -{ 90 + 2*s22 + 2*s23 + -80*z + 20*z^2 }-> s24 :|: s22 >= 0, s22 <= z - 2, s23 >= 0, s23 <= s22 + 1, s24 >= 0, s24 <= s23 + 1, z - 2 >= 0
   encArg(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 1, z - 1 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 26 + -40*z + 20*z^2 }-> 1 + s8 :|: s8 >= 0, s8 <= z - 1, z - 1 >= 0
   encode_0 -{ 0 }-> 0 :|: 
   encode_f(z) -{ 30 + 2*s34 + -40*z + 20*z^2 }-> s35 :|: s34 >= 0, s34 <= z - 1, s35 >= 0, s35 <= 1 + s34 + 1, z - 1 >= 0
   encode_f(z) -{ 29 + 2*s36 + 2*s37 + -40*z + 20*z^2 }-> s38 :|: s36 >= 0, s36 <= z - 1, s37 >= 0, s37 <= s36, s38 >= 0, s38 <= s37 + 1, z - 1 >= 0
   encode_f(z) -{ 30 + 2*s39 + 2*s40 + -40*z + 20*z^2 }-> s41 :|: s39 >= 0, s39 <= z - 1, s40 >= 0, s40 <= s39 + 1, s41 >= 0, s41 <= s40 + 1, z - 1 >= 0
   encode_f(z) -{ 2 }-> s6 :|: s6 >= 0, s6 <= 0 + 1, z = 0
   encode_f(z) -{ 2 }-> s7 :|: s7 >= 0, s7 <= 0 + 1, z >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 29 + 2*s25 + -40*z + 20*z^2 }-> s26 :|: s25 >= 0, s25 <= z - 1, s26 >= 0, s26 <= 1 + s25, z - 1 >= 0
   encode_g(z) -{ 28 + 2*s27 + 2*s28 + -40*z + 20*z^2 }-> s29 :|: s27 >= 0, s27 <= z - 1, s28 >= 0, s28 <= s27, s29 >= 0, s29 <= s28, z - 1 >= 0
   encode_g(z) -{ 29 + 2*s30 + 2*s31 + -40*z + 20*z^2 }-> s32 :|: s30 >= 0, s30 <= z - 1, s31 >= 0, s31 <= s30 + 1, s32 >= 0, s32 <= s31, z - 1 >= 0
   encode_g(z) -{ 1 }-> s4 :|: s4 >= 0, s4 <= 0, z = 0
   encode_g(z) -{ 1 }-> s5 :|: s5 >= 0, s5 <= 0, z >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 6 + 20*z^2 }-> 1 + s33 :|: s33 >= 0, s33 <= z, z >= 0
   f(z) -{ 0 }-> 0 :|: z >= 0
   f(z) -{ 1 }-> 1 + 0 :|: z = 0
   f(z) -{ 2*z }-> 1 + (1 + s') :|: s' >= 0, s' <= z - 1, z - 1 >= 0
   g(z) -{ 1 + 2*z }-> s :|: s >= 0, s <= z - 1 + 1, z - 1 >= 0
   g(z) -{ 1 }-> 0 :|: z = 0
   g(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {encode_f}, {encode_g}, {encode_s}
Previous analysis results are:
  encode_0: runtime: O(1) [0], size: O(1) [0]
  f: runtime: O(n^1) [2 + 2*z], size: O(n^1) [1 + z]
  g: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z]
  encArg: runtime: O(n^2) [6 + 20*z^2], size: O(n^1) [z]

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

(41) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   encArg(z) -{ 1 }-> s'' :|: s'' >= 0, s'' <= 0, z = 1 + 0
   encArg(z) -{ 1 }-> s1 :|: s1 >= 0, s1 <= 0, z - 1 >= 0
   encArg(z) -{ 89 + 2*s9 + -80*z + 20*z^2 }-> s10 :|: s9 >= 0, s9 <= z - 2, s10 >= 0, s10 <= 1 + s9, z - 2 >= 0
   encArg(z) -{ 88 + 2*s11 + 2*s12 + -80*z + 20*z^2 }-> s13 :|: s11 >= 0, s11 <= z - 2, s12 >= 0, s12 <= s11, s13 >= 0, s13 <= s12, z - 2 >= 0
   encArg(z) -{ 89 + 2*s14 + 2*s15 + -80*z + 20*z^2 }-> s16 :|: s14 >= 0, s14 <= z - 2, s15 >= 0, s15 <= s14 + 1, s16 >= 0, s16 <= s15, z - 2 >= 0
   encArg(z) -{ 90 + 2*s17 + -80*z + 20*z^2 }-> s18 :|: s17 >= 0, s17 <= z - 2, s18 >= 0, s18 <= 1 + s17 + 1, z - 2 >= 0
   encArg(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 0 + 1, z = 1 + 0
   encArg(z) -{ 89 + 2*s19 + 2*s20 + -80*z + 20*z^2 }-> s21 :|: s19 >= 0, s19 <= z - 2, s20 >= 0, s20 <= s19, s21 >= 0, s21 <= s20 + 1, z - 2 >= 0
   encArg(z) -{ 90 + 2*s22 + 2*s23 + -80*z + 20*z^2 }-> s24 :|: s22 >= 0, s22 <= z - 2, s23 >= 0, s23 <= s22 + 1, s24 >= 0, s24 <= s23 + 1, z - 2 >= 0
   encArg(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 1, z - 1 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 26 + -40*z + 20*z^2 }-> 1 + s8 :|: s8 >= 0, s8 <= z - 1, z - 1 >= 0
   encode_0 -{ 0 }-> 0 :|: 
   encode_f(z) -{ 30 + 2*s34 + -40*z + 20*z^2 }-> s35 :|: s34 >= 0, s34 <= z - 1, s35 >= 0, s35 <= 1 + s34 + 1, z - 1 >= 0
   encode_f(z) -{ 29 + 2*s36 + 2*s37 + -40*z + 20*z^2 }-> s38 :|: s36 >= 0, s36 <= z - 1, s37 >= 0, s37 <= s36, s38 >= 0, s38 <= s37 + 1, z - 1 >= 0
   encode_f(z) -{ 30 + 2*s39 + 2*s40 + -40*z + 20*z^2 }-> s41 :|: s39 >= 0, s39 <= z - 1, s40 >= 0, s40 <= s39 + 1, s41 >= 0, s41 <= s40 + 1, z - 1 >= 0
   encode_f(z) -{ 2 }-> s6 :|: s6 >= 0, s6 <= 0 + 1, z = 0
   encode_f(z) -{ 2 }-> s7 :|: s7 >= 0, s7 <= 0 + 1, z >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 29 + 2*s25 + -40*z + 20*z^2 }-> s26 :|: s25 >= 0, s25 <= z - 1, s26 >= 0, s26 <= 1 + s25, z - 1 >= 0
   encode_g(z) -{ 28 + 2*s27 + 2*s28 + -40*z + 20*z^2 }-> s29 :|: s27 >= 0, s27 <= z - 1, s28 >= 0, s28 <= s27, s29 >= 0, s29 <= s28, z - 1 >= 0
   encode_g(z) -{ 29 + 2*s30 + 2*s31 + -40*z + 20*z^2 }-> s32 :|: s30 >= 0, s30 <= z - 1, s31 >= 0, s31 <= s30 + 1, s32 >= 0, s32 <= s31, z - 1 >= 0
   encode_g(z) -{ 1 }-> s4 :|: s4 >= 0, s4 <= 0, z = 0
   encode_g(z) -{ 1 }-> s5 :|: s5 >= 0, s5 <= 0, z >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 6 + 20*z^2 }-> 1 + s33 :|: s33 >= 0, s33 <= z, z >= 0
   f(z) -{ 0 }-> 0 :|: z >= 0
   f(z) -{ 1 }-> 1 + 0 :|: z = 0
   f(z) -{ 2*z }-> 1 + (1 + s') :|: s' >= 0, s' <= z - 1, z - 1 >= 0
   g(z) -{ 1 + 2*z }-> s :|: s >= 0, s <= z - 1 + 1, z - 1 >= 0
   g(z) -{ 1 }-> 0 :|: z = 0
   g(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {encode_f}, {encode_g}, {encode_s}
Previous analysis results are:
  encode_0: runtime: O(1) [0], size: O(1) [0]
  f: runtime: O(n^1) [2 + 2*z], size: O(n^1) [1 + z]
  g: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z]
  encArg: runtime: O(n^2) [6 + 20*z^2], size: O(n^1) [z]
  encode_f: runtime: ?, size: O(n^1) [1 + z]

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

(43) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   encArg(z) -{ 1 }-> s'' :|: s'' >= 0, s'' <= 0, z = 1 + 0
   encArg(z) -{ 1 }-> s1 :|: s1 >= 0, s1 <= 0, z - 1 >= 0
   encArg(z) -{ 89 + 2*s9 + -80*z + 20*z^2 }-> s10 :|: s9 >= 0, s9 <= z - 2, s10 >= 0, s10 <= 1 + s9, z - 2 >= 0
   encArg(z) -{ 88 + 2*s11 + 2*s12 + -80*z + 20*z^2 }-> s13 :|: s11 >= 0, s11 <= z - 2, s12 >= 0, s12 <= s11, s13 >= 0, s13 <= s12, z - 2 >= 0
   encArg(z) -{ 89 + 2*s14 + 2*s15 + -80*z + 20*z^2 }-> s16 :|: s14 >= 0, s14 <= z - 2, s15 >= 0, s15 <= s14 + 1, s16 >= 0, s16 <= s15, z - 2 >= 0
   encArg(z) -{ 90 + 2*s17 + -80*z + 20*z^2 }-> s18 :|: s17 >= 0, s17 <= z - 2, s18 >= 0, s18 <= 1 + s17 + 1, z - 2 >= 0
   encArg(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 0 + 1, z = 1 + 0
   encArg(z) -{ 89 + 2*s19 + 2*s20 + -80*z + 20*z^2 }-> s21 :|: s19 >= 0, s19 <= z - 2, s20 >= 0, s20 <= s19, s21 >= 0, s21 <= s20 + 1, z - 2 >= 0
   encArg(z) -{ 90 + 2*s22 + 2*s23 + -80*z + 20*z^2 }-> s24 :|: s22 >= 0, s22 <= z - 2, s23 >= 0, s23 <= s22 + 1, s24 >= 0, s24 <= s23 + 1, z - 2 >= 0
   encArg(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 1, z - 1 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 26 + -40*z + 20*z^2 }-> 1 + s8 :|: s8 >= 0, s8 <= z - 1, z - 1 >= 0
   encode_0 -{ 0 }-> 0 :|: 
   encode_f(z) -{ 30 + 2*s34 + -40*z + 20*z^2 }-> s35 :|: s34 >= 0, s34 <= z - 1, s35 >= 0, s35 <= 1 + s34 + 1, z - 1 >= 0
   encode_f(z) -{ 29 + 2*s36 + 2*s37 + -40*z + 20*z^2 }-> s38 :|: s36 >= 0, s36 <= z - 1, s37 >= 0, s37 <= s36, s38 >= 0, s38 <= s37 + 1, z - 1 >= 0
   encode_f(z) -{ 30 + 2*s39 + 2*s40 + -40*z + 20*z^2 }-> s41 :|: s39 >= 0, s39 <= z - 1, s40 >= 0, s40 <= s39 + 1, s41 >= 0, s41 <= s40 + 1, z - 1 >= 0
   encode_f(z) -{ 2 }-> s6 :|: s6 >= 0, s6 <= 0 + 1, z = 0
   encode_f(z) -{ 2 }-> s7 :|: s7 >= 0, s7 <= 0 + 1, z >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 29 + 2*s25 + -40*z + 20*z^2 }-> s26 :|: s25 >= 0, s25 <= z - 1, s26 >= 0, s26 <= 1 + s25, z - 1 >= 0
   encode_g(z) -{ 28 + 2*s27 + 2*s28 + -40*z + 20*z^2 }-> s29 :|: s27 >= 0, s27 <= z - 1, s28 >= 0, s28 <= s27, s29 >= 0, s29 <= s28, z - 1 >= 0
   encode_g(z) -{ 29 + 2*s30 + 2*s31 + -40*z + 20*z^2 }-> s32 :|: s30 >= 0, s30 <= z - 1, s31 >= 0, s31 <= s30 + 1, s32 >= 0, s32 <= s31, z - 1 >= 0
   encode_g(z) -{ 1 }-> s4 :|: s4 >= 0, s4 <= 0, z = 0
   encode_g(z) -{ 1 }-> s5 :|: s5 >= 0, s5 <= 0, z >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 6 + 20*z^2 }-> 1 + s33 :|: s33 >= 0, s33 <= z, z >= 0
   f(z) -{ 0 }-> 0 :|: z >= 0
   f(z) -{ 1 }-> 1 + 0 :|: z = 0
   f(z) -{ 2*z }-> 1 + (1 + s') :|: s' >= 0, s' <= z - 1, z - 1 >= 0
   g(z) -{ 1 + 2*z }-> s :|: s >= 0, s <= z - 1 + 1, z - 1 >= 0
   g(z) -{ 1 }-> 0 :|: z = 0
   g(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {encode_g}, {encode_s}
Previous analysis results are:
  encode_0: runtime: O(1) [0], size: O(1) [0]
  f: runtime: O(n^1) [2 + 2*z], size: O(n^1) [1 + z]
  g: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z]
  encArg: runtime: O(n^2) [6 + 20*z^2], size: O(n^1) [z]
  encode_f: runtime: O(n^2) [93 + 60*z^2], size: O(n^1) [1 + 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:

   encArg(z) -{ 1 }-> s'' :|: s'' >= 0, s'' <= 0, z = 1 + 0
   encArg(z) -{ 1 }-> s1 :|: s1 >= 0, s1 <= 0, z - 1 >= 0
   encArg(z) -{ 89 + 2*s9 + -80*z + 20*z^2 }-> s10 :|: s9 >= 0, s9 <= z - 2, s10 >= 0, s10 <= 1 + s9, z - 2 >= 0
   encArg(z) -{ 88 + 2*s11 + 2*s12 + -80*z + 20*z^2 }-> s13 :|: s11 >= 0, s11 <= z - 2, s12 >= 0, s12 <= s11, s13 >= 0, s13 <= s12, z - 2 >= 0
   encArg(z) -{ 89 + 2*s14 + 2*s15 + -80*z + 20*z^2 }-> s16 :|: s14 >= 0, s14 <= z - 2, s15 >= 0, s15 <= s14 + 1, s16 >= 0, s16 <= s15, z - 2 >= 0
   encArg(z) -{ 90 + 2*s17 + -80*z + 20*z^2 }-> s18 :|: s17 >= 0, s17 <= z - 2, s18 >= 0, s18 <= 1 + s17 + 1, z - 2 >= 0
   encArg(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 0 + 1, z = 1 + 0
   encArg(z) -{ 89 + 2*s19 + 2*s20 + -80*z + 20*z^2 }-> s21 :|: s19 >= 0, s19 <= z - 2, s20 >= 0, s20 <= s19, s21 >= 0, s21 <= s20 + 1, z - 2 >= 0
   encArg(z) -{ 90 + 2*s22 + 2*s23 + -80*z + 20*z^2 }-> s24 :|: s22 >= 0, s22 <= z - 2, s23 >= 0, s23 <= s22 + 1, s24 >= 0, s24 <= s23 + 1, z - 2 >= 0
   encArg(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 1, z - 1 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 26 + -40*z + 20*z^2 }-> 1 + s8 :|: s8 >= 0, s8 <= z - 1, z - 1 >= 0
   encode_0 -{ 0 }-> 0 :|: 
   encode_f(z) -{ 30 + 2*s34 + -40*z + 20*z^2 }-> s35 :|: s34 >= 0, s34 <= z - 1, s35 >= 0, s35 <= 1 + s34 + 1, z - 1 >= 0
   encode_f(z) -{ 29 + 2*s36 + 2*s37 + -40*z + 20*z^2 }-> s38 :|: s36 >= 0, s36 <= z - 1, s37 >= 0, s37 <= s36, s38 >= 0, s38 <= s37 + 1, z - 1 >= 0
   encode_f(z) -{ 30 + 2*s39 + 2*s40 + -40*z + 20*z^2 }-> s41 :|: s39 >= 0, s39 <= z - 1, s40 >= 0, s40 <= s39 + 1, s41 >= 0, s41 <= s40 + 1, z - 1 >= 0
   encode_f(z) -{ 2 }-> s6 :|: s6 >= 0, s6 <= 0 + 1, z = 0
   encode_f(z) -{ 2 }-> s7 :|: s7 >= 0, s7 <= 0 + 1, z >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 29 + 2*s25 + -40*z + 20*z^2 }-> s26 :|: s25 >= 0, s25 <= z - 1, s26 >= 0, s26 <= 1 + s25, z - 1 >= 0
   encode_g(z) -{ 28 + 2*s27 + 2*s28 + -40*z + 20*z^2 }-> s29 :|: s27 >= 0, s27 <= z - 1, s28 >= 0, s28 <= s27, s29 >= 0, s29 <= s28, z - 1 >= 0
   encode_g(z) -{ 29 + 2*s30 + 2*s31 + -40*z + 20*z^2 }-> s32 :|: s30 >= 0, s30 <= z - 1, s31 >= 0, s31 <= s30 + 1, s32 >= 0, s32 <= s31, z - 1 >= 0
   encode_g(z) -{ 1 }-> s4 :|: s4 >= 0, s4 <= 0, z = 0
   encode_g(z) -{ 1 }-> s5 :|: s5 >= 0, s5 <= 0, z >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 6 + 20*z^2 }-> 1 + s33 :|: s33 >= 0, s33 <= z, z >= 0
   f(z) -{ 0 }-> 0 :|: z >= 0
   f(z) -{ 1 }-> 1 + 0 :|: z = 0
   f(z) -{ 2*z }-> 1 + (1 + s') :|: s' >= 0, s' <= z - 1, z - 1 >= 0
   g(z) -{ 1 + 2*z }-> s :|: s >= 0, s <= z - 1 + 1, z - 1 >= 0
   g(z) -{ 1 }-> 0 :|: z = 0
   g(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {encode_g}, {encode_s}
Previous analysis results are:
  encode_0: runtime: O(1) [0], size: O(1) [0]
  f: runtime: O(n^1) [2 + 2*z], size: O(n^1) [1 + z]
  g: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z]
  encArg: runtime: O(n^2) [6 + 20*z^2], size: O(n^1) [z]
  encode_f: runtime: O(n^2) [93 + 60*z^2], size: O(n^1) [1 + z]

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

(47) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   encArg(z) -{ 1 }-> s'' :|: s'' >= 0, s'' <= 0, z = 1 + 0
   encArg(z) -{ 1 }-> s1 :|: s1 >= 0, s1 <= 0, z - 1 >= 0
   encArg(z) -{ 89 + 2*s9 + -80*z + 20*z^2 }-> s10 :|: s9 >= 0, s9 <= z - 2, s10 >= 0, s10 <= 1 + s9, z - 2 >= 0
   encArg(z) -{ 88 + 2*s11 + 2*s12 + -80*z + 20*z^2 }-> s13 :|: s11 >= 0, s11 <= z - 2, s12 >= 0, s12 <= s11, s13 >= 0, s13 <= s12, z - 2 >= 0
   encArg(z) -{ 89 + 2*s14 + 2*s15 + -80*z + 20*z^2 }-> s16 :|: s14 >= 0, s14 <= z - 2, s15 >= 0, s15 <= s14 + 1, s16 >= 0, s16 <= s15, z - 2 >= 0
   encArg(z) -{ 90 + 2*s17 + -80*z + 20*z^2 }-> s18 :|: s17 >= 0, s17 <= z - 2, s18 >= 0, s18 <= 1 + s17 + 1, z - 2 >= 0
   encArg(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 0 + 1, z = 1 + 0
   encArg(z) -{ 89 + 2*s19 + 2*s20 + -80*z + 20*z^2 }-> s21 :|: s19 >= 0, s19 <= z - 2, s20 >= 0, s20 <= s19, s21 >= 0, s21 <= s20 + 1, z - 2 >= 0
   encArg(z) -{ 90 + 2*s22 + 2*s23 + -80*z + 20*z^2 }-> s24 :|: s22 >= 0, s22 <= z - 2, s23 >= 0, s23 <= s22 + 1, s24 >= 0, s24 <= s23 + 1, z - 2 >= 0
   encArg(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 1, z - 1 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 26 + -40*z + 20*z^2 }-> 1 + s8 :|: s8 >= 0, s8 <= z - 1, z - 1 >= 0
   encode_0 -{ 0 }-> 0 :|: 
   encode_f(z) -{ 30 + 2*s34 + -40*z + 20*z^2 }-> s35 :|: s34 >= 0, s34 <= z - 1, s35 >= 0, s35 <= 1 + s34 + 1, z - 1 >= 0
   encode_f(z) -{ 29 + 2*s36 + 2*s37 + -40*z + 20*z^2 }-> s38 :|: s36 >= 0, s36 <= z - 1, s37 >= 0, s37 <= s36, s38 >= 0, s38 <= s37 + 1, z - 1 >= 0
   encode_f(z) -{ 30 + 2*s39 + 2*s40 + -40*z + 20*z^2 }-> s41 :|: s39 >= 0, s39 <= z - 1, s40 >= 0, s40 <= s39 + 1, s41 >= 0, s41 <= s40 + 1, z - 1 >= 0
   encode_f(z) -{ 2 }-> s6 :|: s6 >= 0, s6 <= 0 + 1, z = 0
   encode_f(z) -{ 2 }-> s7 :|: s7 >= 0, s7 <= 0 + 1, z >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 29 + 2*s25 + -40*z + 20*z^2 }-> s26 :|: s25 >= 0, s25 <= z - 1, s26 >= 0, s26 <= 1 + s25, z - 1 >= 0
   encode_g(z) -{ 28 + 2*s27 + 2*s28 + -40*z + 20*z^2 }-> s29 :|: s27 >= 0, s27 <= z - 1, s28 >= 0, s28 <= s27, s29 >= 0, s29 <= s28, z - 1 >= 0
   encode_g(z) -{ 29 + 2*s30 + 2*s31 + -40*z + 20*z^2 }-> s32 :|: s30 >= 0, s30 <= z - 1, s31 >= 0, s31 <= s30 + 1, s32 >= 0, s32 <= s31, z - 1 >= 0
   encode_g(z) -{ 1 }-> s4 :|: s4 >= 0, s4 <= 0, z = 0
   encode_g(z) -{ 1 }-> s5 :|: s5 >= 0, s5 <= 0, z >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 6 + 20*z^2 }-> 1 + s33 :|: s33 >= 0, s33 <= z, z >= 0
   f(z) -{ 0 }-> 0 :|: z >= 0
   f(z) -{ 1 }-> 1 + 0 :|: z = 0
   f(z) -{ 2*z }-> 1 + (1 + s') :|: s' >= 0, s' <= z - 1, z - 1 >= 0
   g(z) -{ 1 + 2*z }-> s :|: s >= 0, s <= z - 1 + 1, z - 1 >= 0
   g(z) -{ 1 }-> 0 :|: z = 0
   g(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {encode_g}, {encode_s}
Previous analysis results are:
  encode_0: runtime: O(1) [0], size: O(1) [0]
  f: runtime: O(n^1) [2 + 2*z], size: O(n^1) [1 + z]
  g: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z]
  encArg: runtime: O(n^2) [6 + 20*z^2], size: O(n^1) [z]
  encode_f: runtime: O(n^2) [93 + 60*z^2], size: O(n^1) [1 + z]
  encode_g: runtime: ?, size: O(n^1) [z]

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

(49) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   encArg(z) -{ 1 }-> s'' :|: s'' >= 0, s'' <= 0, z = 1 + 0
   encArg(z) -{ 1 }-> s1 :|: s1 >= 0, s1 <= 0, z - 1 >= 0
   encArg(z) -{ 89 + 2*s9 + -80*z + 20*z^2 }-> s10 :|: s9 >= 0, s9 <= z - 2, s10 >= 0, s10 <= 1 + s9, z - 2 >= 0
   encArg(z) -{ 88 + 2*s11 + 2*s12 + -80*z + 20*z^2 }-> s13 :|: s11 >= 0, s11 <= z - 2, s12 >= 0, s12 <= s11, s13 >= 0, s13 <= s12, z - 2 >= 0
   encArg(z) -{ 89 + 2*s14 + 2*s15 + -80*z + 20*z^2 }-> s16 :|: s14 >= 0, s14 <= z - 2, s15 >= 0, s15 <= s14 + 1, s16 >= 0, s16 <= s15, z - 2 >= 0
   encArg(z) -{ 90 + 2*s17 + -80*z + 20*z^2 }-> s18 :|: s17 >= 0, s17 <= z - 2, s18 >= 0, s18 <= 1 + s17 + 1, z - 2 >= 0
   encArg(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 0 + 1, z = 1 + 0
   encArg(z) -{ 89 + 2*s19 + 2*s20 + -80*z + 20*z^2 }-> s21 :|: s19 >= 0, s19 <= z - 2, s20 >= 0, s20 <= s19, s21 >= 0, s21 <= s20 + 1, z - 2 >= 0
   encArg(z) -{ 90 + 2*s22 + 2*s23 + -80*z + 20*z^2 }-> s24 :|: s22 >= 0, s22 <= z - 2, s23 >= 0, s23 <= s22 + 1, s24 >= 0, s24 <= s23 + 1, z - 2 >= 0
   encArg(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 1, z - 1 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 26 + -40*z + 20*z^2 }-> 1 + s8 :|: s8 >= 0, s8 <= z - 1, z - 1 >= 0
   encode_0 -{ 0 }-> 0 :|: 
   encode_f(z) -{ 30 + 2*s34 + -40*z + 20*z^2 }-> s35 :|: s34 >= 0, s34 <= z - 1, s35 >= 0, s35 <= 1 + s34 + 1, z - 1 >= 0
   encode_f(z) -{ 29 + 2*s36 + 2*s37 + -40*z + 20*z^2 }-> s38 :|: s36 >= 0, s36 <= z - 1, s37 >= 0, s37 <= s36, s38 >= 0, s38 <= s37 + 1, z - 1 >= 0
   encode_f(z) -{ 30 + 2*s39 + 2*s40 + -40*z + 20*z^2 }-> s41 :|: s39 >= 0, s39 <= z - 1, s40 >= 0, s40 <= s39 + 1, s41 >= 0, s41 <= s40 + 1, z - 1 >= 0
   encode_f(z) -{ 2 }-> s6 :|: s6 >= 0, s6 <= 0 + 1, z = 0
   encode_f(z) -{ 2 }-> s7 :|: s7 >= 0, s7 <= 0 + 1, z >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 29 + 2*s25 + -40*z + 20*z^2 }-> s26 :|: s25 >= 0, s25 <= z - 1, s26 >= 0, s26 <= 1 + s25, z - 1 >= 0
   encode_g(z) -{ 28 + 2*s27 + 2*s28 + -40*z + 20*z^2 }-> s29 :|: s27 >= 0, s27 <= z - 1, s28 >= 0, s28 <= s27, s29 >= 0, s29 <= s28, z - 1 >= 0
   encode_g(z) -{ 29 + 2*s30 + 2*s31 + -40*z + 20*z^2 }-> s32 :|: s30 >= 0, s30 <= z - 1, s31 >= 0, s31 <= s30 + 1, s32 >= 0, s32 <= s31, z - 1 >= 0
   encode_g(z) -{ 1 }-> s4 :|: s4 >= 0, s4 <= 0, z = 0
   encode_g(z) -{ 1 }-> s5 :|: s5 >= 0, s5 <= 0, z >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 6 + 20*z^2 }-> 1 + s33 :|: s33 >= 0, s33 <= z, z >= 0
   f(z) -{ 0 }-> 0 :|: z >= 0
   f(z) -{ 1 }-> 1 + 0 :|: z = 0
   f(z) -{ 2*z }-> 1 + (1 + s') :|: s' >= 0, s' <= z - 1, z - 1 >= 0
   g(z) -{ 1 + 2*z }-> s :|: s >= 0, s <= z - 1 + 1, z - 1 >= 0
   g(z) -{ 1 }-> 0 :|: z = 0
   g(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {encode_s}
Previous analysis results are:
  encode_0: runtime: O(1) [0], size: O(1) [0]
  f: runtime: O(n^1) [2 + 2*z], size: O(n^1) [1 + z]
  g: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z]
  encArg: runtime: O(n^2) [6 + 20*z^2], size: O(n^1) [z]
  encode_f: runtime: O(n^2) [93 + 60*z^2], size: O(n^1) [1 + z]
  encode_g: runtime: O(n^2) [88 + 60*z^2], size: O(n^1) [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:

   encArg(z) -{ 1 }-> s'' :|: s'' >= 0, s'' <= 0, z = 1 + 0
   encArg(z) -{ 1 }-> s1 :|: s1 >= 0, s1 <= 0, z - 1 >= 0
   encArg(z) -{ 89 + 2*s9 + -80*z + 20*z^2 }-> s10 :|: s9 >= 0, s9 <= z - 2, s10 >= 0, s10 <= 1 + s9, z - 2 >= 0
   encArg(z) -{ 88 + 2*s11 + 2*s12 + -80*z + 20*z^2 }-> s13 :|: s11 >= 0, s11 <= z - 2, s12 >= 0, s12 <= s11, s13 >= 0, s13 <= s12, z - 2 >= 0
   encArg(z) -{ 89 + 2*s14 + 2*s15 + -80*z + 20*z^2 }-> s16 :|: s14 >= 0, s14 <= z - 2, s15 >= 0, s15 <= s14 + 1, s16 >= 0, s16 <= s15, z - 2 >= 0
   encArg(z) -{ 90 + 2*s17 + -80*z + 20*z^2 }-> s18 :|: s17 >= 0, s17 <= z - 2, s18 >= 0, s18 <= 1 + s17 + 1, z - 2 >= 0
   encArg(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 0 + 1, z = 1 + 0
   encArg(z) -{ 89 + 2*s19 + 2*s20 + -80*z + 20*z^2 }-> s21 :|: s19 >= 0, s19 <= z - 2, s20 >= 0, s20 <= s19, s21 >= 0, s21 <= s20 + 1, z - 2 >= 0
   encArg(z) -{ 90 + 2*s22 + 2*s23 + -80*z + 20*z^2 }-> s24 :|: s22 >= 0, s22 <= z - 2, s23 >= 0, s23 <= s22 + 1, s24 >= 0, s24 <= s23 + 1, z - 2 >= 0
   encArg(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 1, z - 1 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 26 + -40*z + 20*z^2 }-> 1 + s8 :|: s8 >= 0, s8 <= z - 1, z - 1 >= 0
   encode_0 -{ 0 }-> 0 :|: 
   encode_f(z) -{ 30 + 2*s34 + -40*z + 20*z^2 }-> s35 :|: s34 >= 0, s34 <= z - 1, s35 >= 0, s35 <= 1 + s34 + 1, z - 1 >= 0
   encode_f(z) -{ 29 + 2*s36 + 2*s37 + -40*z + 20*z^2 }-> s38 :|: s36 >= 0, s36 <= z - 1, s37 >= 0, s37 <= s36, s38 >= 0, s38 <= s37 + 1, z - 1 >= 0
   encode_f(z) -{ 30 + 2*s39 + 2*s40 + -40*z + 20*z^2 }-> s41 :|: s39 >= 0, s39 <= z - 1, s40 >= 0, s40 <= s39 + 1, s41 >= 0, s41 <= s40 + 1, z - 1 >= 0
   encode_f(z) -{ 2 }-> s6 :|: s6 >= 0, s6 <= 0 + 1, z = 0
   encode_f(z) -{ 2 }-> s7 :|: s7 >= 0, s7 <= 0 + 1, z >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 29 + 2*s25 + -40*z + 20*z^2 }-> s26 :|: s25 >= 0, s25 <= z - 1, s26 >= 0, s26 <= 1 + s25, z - 1 >= 0
   encode_g(z) -{ 28 + 2*s27 + 2*s28 + -40*z + 20*z^2 }-> s29 :|: s27 >= 0, s27 <= z - 1, s28 >= 0, s28 <= s27, s29 >= 0, s29 <= s28, z - 1 >= 0
   encode_g(z) -{ 29 + 2*s30 + 2*s31 + -40*z + 20*z^2 }-> s32 :|: s30 >= 0, s30 <= z - 1, s31 >= 0, s31 <= s30 + 1, s32 >= 0, s32 <= s31, z - 1 >= 0
   encode_g(z) -{ 1 }-> s4 :|: s4 >= 0, s4 <= 0, z = 0
   encode_g(z) -{ 1 }-> s5 :|: s5 >= 0, s5 <= 0, z >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 6 + 20*z^2 }-> 1 + s33 :|: s33 >= 0, s33 <= z, z >= 0
   f(z) -{ 0 }-> 0 :|: z >= 0
   f(z) -{ 1 }-> 1 + 0 :|: z = 0
   f(z) -{ 2*z }-> 1 + (1 + s') :|: s' >= 0, s' <= z - 1, z - 1 >= 0
   g(z) -{ 1 + 2*z }-> s :|: s >= 0, s <= z - 1 + 1, z - 1 >= 0
   g(z) -{ 1 }-> 0 :|: z = 0
   g(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {encode_s}
Previous analysis results are:
  encode_0: runtime: O(1) [0], size: O(1) [0]
  f: runtime: O(n^1) [2 + 2*z], size: O(n^1) [1 + z]
  g: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z]
  encArg: runtime: O(n^2) [6 + 20*z^2], size: O(n^1) [z]
  encode_f: runtime: O(n^2) [93 + 60*z^2], size: O(n^1) [1 + z]
  encode_g: runtime: O(n^2) [88 + 60*z^2], size: O(n^1) [z]

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

(53) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   encArg(z) -{ 1 }-> s'' :|: s'' >= 0, s'' <= 0, z = 1 + 0
   encArg(z) -{ 1 }-> s1 :|: s1 >= 0, s1 <= 0, z - 1 >= 0
   encArg(z) -{ 89 + 2*s9 + -80*z + 20*z^2 }-> s10 :|: s9 >= 0, s9 <= z - 2, s10 >= 0, s10 <= 1 + s9, z - 2 >= 0
   encArg(z) -{ 88 + 2*s11 + 2*s12 + -80*z + 20*z^2 }-> s13 :|: s11 >= 0, s11 <= z - 2, s12 >= 0, s12 <= s11, s13 >= 0, s13 <= s12, z - 2 >= 0
   encArg(z) -{ 89 + 2*s14 + 2*s15 + -80*z + 20*z^2 }-> s16 :|: s14 >= 0, s14 <= z - 2, s15 >= 0, s15 <= s14 + 1, s16 >= 0, s16 <= s15, z - 2 >= 0
   encArg(z) -{ 90 + 2*s17 + -80*z + 20*z^2 }-> s18 :|: s17 >= 0, s17 <= z - 2, s18 >= 0, s18 <= 1 + s17 + 1, z - 2 >= 0
   encArg(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 0 + 1, z = 1 + 0
   encArg(z) -{ 89 + 2*s19 + 2*s20 + -80*z + 20*z^2 }-> s21 :|: s19 >= 0, s19 <= z - 2, s20 >= 0, s20 <= s19, s21 >= 0, s21 <= s20 + 1, z - 2 >= 0
   encArg(z) -{ 90 + 2*s22 + 2*s23 + -80*z + 20*z^2 }-> s24 :|: s22 >= 0, s22 <= z - 2, s23 >= 0, s23 <= s22 + 1, s24 >= 0, s24 <= s23 + 1, z - 2 >= 0
   encArg(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 1, z - 1 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 26 + -40*z + 20*z^2 }-> 1 + s8 :|: s8 >= 0, s8 <= z - 1, z - 1 >= 0
   encode_0 -{ 0 }-> 0 :|: 
   encode_f(z) -{ 30 + 2*s34 + -40*z + 20*z^2 }-> s35 :|: s34 >= 0, s34 <= z - 1, s35 >= 0, s35 <= 1 + s34 + 1, z - 1 >= 0
   encode_f(z) -{ 29 + 2*s36 + 2*s37 + -40*z + 20*z^2 }-> s38 :|: s36 >= 0, s36 <= z - 1, s37 >= 0, s37 <= s36, s38 >= 0, s38 <= s37 + 1, z - 1 >= 0
   encode_f(z) -{ 30 + 2*s39 + 2*s40 + -40*z + 20*z^2 }-> s41 :|: s39 >= 0, s39 <= z - 1, s40 >= 0, s40 <= s39 + 1, s41 >= 0, s41 <= s40 + 1, z - 1 >= 0
   encode_f(z) -{ 2 }-> s6 :|: s6 >= 0, s6 <= 0 + 1, z = 0
   encode_f(z) -{ 2 }-> s7 :|: s7 >= 0, s7 <= 0 + 1, z >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 29 + 2*s25 + -40*z + 20*z^2 }-> s26 :|: s25 >= 0, s25 <= z - 1, s26 >= 0, s26 <= 1 + s25, z - 1 >= 0
   encode_g(z) -{ 28 + 2*s27 + 2*s28 + -40*z + 20*z^2 }-> s29 :|: s27 >= 0, s27 <= z - 1, s28 >= 0, s28 <= s27, s29 >= 0, s29 <= s28, z - 1 >= 0
   encode_g(z) -{ 29 + 2*s30 + 2*s31 + -40*z + 20*z^2 }-> s32 :|: s30 >= 0, s30 <= z - 1, s31 >= 0, s31 <= s30 + 1, s32 >= 0, s32 <= s31, z - 1 >= 0
   encode_g(z) -{ 1 }-> s4 :|: s4 >= 0, s4 <= 0, z = 0
   encode_g(z) -{ 1 }-> s5 :|: s5 >= 0, s5 <= 0, z >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 6 + 20*z^2 }-> 1 + s33 :|: s33 >= 0, s33 <= z, z >= 0
   f(z) -{ 0 }-> 0 :|: z >= 0
   f(z) -{ 1 }-> 1 + 0 :|: z = 0
   f(z) -{ 2*z }-> 1 + (1 + s') :|: s' >= 0, s' <= z - 1, z - 1 >= 0
   g(z) -{ 1 + 2*z }-> s :|: s >= 0, s <= z - 1 + 1, z - 1 >= 0
   g(z) -{ 1 }-> 0 :|: z = 0
   g(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: {encode_s}
Previous analysis results are:
  encode_0: runtime: O(1) [0], size: O(1) [0]
  f: runtime: O(n^1) [2 + 2*z], size: O(n^1) [1 + z]
  g: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z]
  encArg: runtime: O(n^2) [6 + 20*z^2], size: O(n^1) [z]
  encode_f: runtime: O(n^2) [93 + 60*z^2], size: O(n^1) [1 + z]
  encode_g: runtime: O(n^2) [88 + 60*z^2], size: O(n^1) [z]
  encode_s: runtime: ?, size: O(n^1) [1 + z]

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

(55) IntTrsBoundProof (UPPER BOUND(ID))

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

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

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

   encArg(z) -{ 1 }-> s'' :|: s'' >= 0, s'' <= 0, z = 1 + 0
   encArg(z) -{ 1 }-> s1 :|: s1 >= 0, s1 <= 0, z - 1 >= 0
   encArg(z) -{ 89 + 2*s9 + -80*z + 20*z^2 }-> s10 :|: s9 >= 0, s9 <= z - 2, s10 >= 0, s10 <= 1 + s9, z - 2 >= 0
   encArg(z) -{ 88 + 2*s11 + 2*s12 + -80*z + 20*z^2 }-> s13 :|: s11 >= 0, s11 <= z - 2, s12 >= 0, s12 <= s11, s13 >= 0, s13 <= s12, z - 2 >= 0
   encArg(z) -{ 89 + 2*s14 + 2*s15 + -80*z + 20*z^2 }-> s16 :|: s14 >= 0, s14 <= z - 2, s15 >= 0, s15 <= s14 + 1, s16 >= 0, s16 <= s15, z - 2 >= 0
   encArg(z) -{ 90 + 2*s17 + -80*z + 20*z^2 }-> s18 :|: s17 >= 0, s17 <= z - 2, s18 >= 0, s18 <= 1 + s17 + 1, z - 2 >= 0
   encArg(z) -{ 2 }-> s2 :|: s2 >= 0, s2 <= 0 + 1, z = 1 + 0
   encArg(z) -{ 89 + 2*s19 + 2*s20 + -80*z + 20*z^2 }-> s21 :|: s19 >= 0, s19 <= z - 2, s20 >= 0, s20 <= s19, s21 >= 0, s21 <= s20 + 1, z - 2 >= 0
   encArg(z) -{ 90 + 2*s22 + 2*s23 + -80*z + 20*z^2 }-> s24 :|: s22 >= 0, s22 <= z - 2, s23 >= 0, s23 <= s22 + 1, s24 >= 0, s24 <= s23 + 1, z - 2 >= 0
   encArg(z) -{ 2 }-> s3 :|: s3 >= 0, s3 <= 0 + 1, z - 1 >= 0
   encArg(z) -{ 0 }-> 0 :|: z = 0
   encArg(z) -{ 0 }-> 0 :|: z >= 0
   encArg(z) -{ 26 + -40*z + 20*z^2 }-> 1 + s8 :|: s8 >= 0, s8 <= z - 1, z - 1 >= 0
   encode_0 -{ 0 }-> 0 :|: 
   encode_f(z) -{ 30 + 2*s34 + -40*z + 20*z^2 }-> s35 :|: s34 >= 0, s34 <= z - 1, s35 >= 0, s35 <= 1 + s34 + 1, z - 1 >= 0
   encode_f(z) -{ 29 + 2*s36 + 2*s37 + -40*z + 20*z^2 }-> s38 :|: s36 >= 0, s36 <= z - 1, s37 >= 0, s37 <= s36, s38 >= 0, s38 <= s37 + 1, z - 1 >= 0
   encode_f(z) -{ 30 + 2*s39 + 2*s40 + -40*z + 20*z^2 }-> s41 :|: s39 >= 0, s39 <= z - 1, s40 >= 0, s40 <= s39 + 1, s41 >= 0, s41 <= s40 + 1, z - 1 >= 0
   encode_f(z) -{ 2 }-> s6 :|: s6 >= 0, s6 <= 0 + 1, z = 0
   encode_f(z) -{ 2 }-> s7 :|: s7 >= 0, s7 <= 0 + 1, z >= 0
   encode_f(z) -{ 0 }-> 0 :|: z >= 0
   encode_g(z) -{ 29 + 2*s25 + -40*z + 20*z^2 }-> s26 :|: s25 >= 0, s25 <= z - 1, s26 >= 0, s26 <= 1 + s25, z - 1 >= 0
   encode_g(z) -{ 28 + 2*s27 + 2*s28 + -40*z + 20*z^2 }-> s29 :|: s27 >= 0, s27 <= z - 1, s28 >= 0, s28 <= s27, s29 >= 0, s29 <= s28, z - 1 >= 0
   encode_g(z) -{ 29 + 2*s30 + 2*s31 + -40*z + 20*z^2 }-> s32 :|: s30 >= 0, s30 <= z - 1, s31 >= 0, s31 <= s30 + 1, s32 >= 0, s32 <= s31, z - 1 >= 0
   encode_g(z) -{ 1 }-> s4 :|: s4 >= 0, s4 <= 0, z = 0
   encode_g(z) -{ 1 }-> s5 :|: s5 >= 0, s5 <= 0, z >= 0
   encode_g(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 0 }-> 0 :|: z >= 0
   encode_s(z) -{ 6 + 20*z^2 }-> 1 + s33 :|: s33 >= 0, s33 <= z, z >= 0
   f(z) -{ 0 }-> 0 :|: z >= 0
   f(z) -{ 1 }-> 1 + 0 :|: z = 0
   f(z) -{ 2*z }-> 1 + (1 + s') :|: s' >= 0, s' <= z - 1, z - 1 >= 0
   g(z) -{ 1 + 2*z }-> s :|: s >= 0, s <= z - 1 + 1, z - 1 >= 0
   g(z) -{ 1 }-> 0 :|: z = 0
   g(z) -{ 0 }-> 0 :|: z >= 0

Function symbols to be analyzed: 
Previous analysis results are:
  encode_0: runtime: O(1) [0], size: O(1) [0]
  f: runtime: O(n^1) [2 + 2*z], size: O(n^1) [1 + z]
  g: runtime: O(n^1) [1 + 2*z], size: O(n^1) [z]
  encArg: runtime: O(n^2) [6 + 20*z^2], size: O(n^1) [z]
  encode_f: runtime: O(n^2) [93 + 60*z^2], size: O(n^1) [1 + z]
  encode_g: runtime: O(n^2) [88 + 60*z^2], size: O(n^1) [z]
  encode_s: runtime: O(n^2) [6 + 20*z^2], size: O(n^1) [1 + z]

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

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

(58)
BOUNDS(1, n^2)

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

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

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


The TRS R consists of the following rules:

   g(s(x)) -> f(x)
   f(0') -> s(0')
   f(s(x)) -> s(s(g(x)))
   g(0') -> 0'

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

   encArg(s(x_1)) -> s(encArg(x_1))
   encArg(0') -> 0'
   encArg(cons_g(x_1)) -> g(encArg(x_1))
   encArg(cons_f(x_1)) -> f(encArg(x_1))
   encode_g(x_1) -> g(encArg(x_1))
   encode_s(x_1) -> s(encArg(x_1))
   encode_f(x_1) -> f(encArg(x_1))
   encode_0 -> 0'

Rewrite Strategy: FULL
----------------------------------------

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

(62)
Obligation:
TRS:
Rules:
g(s(x)) -> f(x)
f(0') -> s(0')
f(s(x)) -> s(s(g(x)))
g(0') -> 0'
encArg(s(x_1)) -> s(encArg(x_1))
encArg(0') -> 0'
encArg(cons_g(x_1)) -> g(encArg(x_1))
encArg(cons_f(x_1)) -> f(encArg(x_1))
encode_g(x_1) -> g(encArg(x_1))
encode_s(x_1) -> s(encArg(x_1))
encode_f(x_1) -> f(encArg(x_1))
encode_0 -> 0'

Types:
g :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
s :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
f :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
0' :: s:0':cons_g:cons_f
encArg :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
cons_g :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
cons_f :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
encode_g :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
encode_s :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
encode_f :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
encode_0 :: s:0':cons_g:cons_f
hole_s:0':cons_g:cons_f1_2 :: s:0':cons_g:cons_f
gen_s:0':cons_g:cons_f2_2 :: Nat -> s:0':cons_g:cons_f

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

(63) OrderProof (LOWER BOUND(ID))
Heuristically decided to analyse the following defined symbols:
g, f, encArg

They will be analysed ascendingly in the following order:
g = f
g < encArg
f < encArg

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

(64)
Obligation:
TRS:
Rules:
g(s(x)) -> f(x)
f(0') -> s(0')
f(s(x)) -> s(s(g(x)))
g(0') -> 0'
encArg(s(x_1)) -> s(encArg(x_1))
encArg(0') -> 0'
encArg(cons_g(x_1)) -> g(encArg(x_1))
encArg(cons_f(x_1)) -> f(encArg(x_1))
encode_g(x_1) -> g(encArg(x_1))
encode_s(x_1) -> s(encArg(x_1))
encode_f(x_1) -> f(encArg(x_1))
encode_0 -> 0'

Types:
g :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
s :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
f :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
0' :: s:0':cons_g:cons_f
encArg :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
cons_g :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
cons_f :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
encode_g :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
encode_s :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
encode_f :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
encode_0 :: s:0':cons_g:cons_f
hole_s:0':cons_g:cons_f1_2 :: s:0':cons_g:cons_f
gen_s:0':cons_g:cons_f2_2 :: Nat -> s:0':cons_g:cons_f


Generator Equations:
gen_s:0':cons_g:cons_f2_2(0) <=> 0'
gen_s:0':cons_g:cons_f2_2(+(x, 1)) <=> s(gen_s:0':cons_g:cons_f2_2(x))


The following defined symbols remain to be analysed:
f, g, encArg

They will be analysed ascendingly in the following order:
g = f
g < encArg
f < encArg

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

(65) RewriteLemmaProof (LOWER BOUND(ID))
Proved the following rewrite lemma:
f(gen_s:0':cons_g:cons_f2_2(*(2, n4_2))) -> gen_s:0':cons_g:cons_f2_2(+(1, *(2, n4_2))), rt in Omega(1 + n4_2)

Induction Base:
f(gen_s:0':cons_g:cons_f2_2(*(2, 0))) ->_R^Omega(1)
s(0')

Induction Step:
f(gen_s:0':cons_g:cons_f2_2(*(2, +(n4_2, 1)))) ->_R^Omega(1)
s(s(g(gen_s:0':cons_g:cons_f2_2(+(1, *(2, n4_2)))))) ->_R^Omega(1)
s(s(f(gen_s:0':cons_g:cons_f2_2(*(2, n4_2))))) ->_IH
s(s(gen_s:0':cons_g:cons_f2_2(+(1, *(2, c5_2)))))

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

(66)
Complex Obligation (BEST)

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

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

TRS:
Rules:
g(s(x)) -> f(x)
f(0') -> s(0')
f(s(x)) -> s(s(g(x)))
g(0') -> 0'
encArg(s(x_1)) -> s(encArg(x_1))
encArg(0') -> 0'
encArg(cons_g(x_1)) -> g(encArg(x_1))
encArg(cons_f(x_1)) -> f(encArg(x_1))
encode_g(x_1) -> g(encArg(x_1))
encode_s(x_1) -> s(encArg(x_1))
encode_f(x_1) -> f(encArg(x_1))
encode_0 -> 0'

Types:
g :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
s :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
f :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
0' :: s:0':cons_g:cons_f
encArg :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
cons_g :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
cons_f :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
encode_g :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
encode_s :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
encode_f :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
encode_0 :: s:0':cons_g:cons_f
hole_s:0':cons_g:cons_f1_2 :: s:0':cons_g:cons_f
gen_s:0':cons_g:cons_f2_2 :: Nat -> s:0':cons_g:cons_f


Generator Equations:
gen_s:0':cons_g:cons_f2_2(0) <=> 0'
gen_s:0':cons_g:cons_f2_2(+(x, 1)) <=> s(gen_s:0':cons_g:cons_f2_2(x))


The following defined symbols remain to be analysed:
f, g, encArg

They will be analysed ascendingly in the following order:
g = f
g < encArg
f < encArg

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

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

(69)
BOUNDS(n^1, INF)

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

(70)
Obligation:
TRS:
Rules:
g(s(x)) -> f(x)
f(0') -> s(0')
f(s(x)) -> s(s(g(x)))
g(0') -> 0'
encArg(s(x_1)) -> s(encArg(x_1))
encArg(0') -> 0'
encArg(cons_g(x_1)) -> g(encArg(x_1))
encArg(cons_f(x_1)) -> f(encArg(x_1))
encode_g(x_1) -> g(encArg(x_1))
encode_s(x_1) -> s(encArg(x_1))
encode_f(x_1) -> f(encArg(x_1))
encode_0 -> 0'

Types:
g :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
s :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
f :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
0' :: s:0':cons_g:cons_f
encArg :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
cons_g :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
cons_f :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
encode_g :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
encode_s :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
encode_f :: s:0':cons_g:cons_f -> s:0':cons_g:cons_f
encode_0 :: s:0':cons_g:cons_f
hole_s:0':cons_g:cons_f1_2 :: s:0':cons_g:cons_f
gen_s:0':cons_g:cons_f2_2 :: Nat -> s:0':cons_g:cons_f


Lemmas:
f(gen_s:0':cons_g:cons_f2_2(*(2, n4_2))) -> gen_s:0':cons_g:cons_f2_2(+(1, *(2, n4_2))), rt in Omega(1 + n4_2)


Generator Equations:
gen_s:0':cons_g:cons_f2_2(0) <=> 0'
gen_s:0':cons_g:cons_f2_2(+(x, 1)) <=> s(gen_s:0':cons_g:cons_f2_2(x))


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

They will be analysed ascendingly in the following order:
g = f
g < encArg
f < encArg

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

(71) RewriteLemmaProof (LOWER BOUND(ID))
Proved the following rewrite lemma:
encArg(gen_s:0':cons_g:cons_f2_2(n237_2)) -> gen_s:0':cons_g:cons_f2_2(n237_2), rt in Omega(0)

Induction Base:
encArg(gen_s:0':cons_g:cons_f2_2(0)) ->_R^Omega(0)
0'

Induction Step:
encArg(gen_s:0':cons_g:cons_f2_2(+(n237_2, 1))) ->_R^Omega(0)
s(encArg(gen_s:0':cons_g:cons_f2_2(n237_2))) ->_IH
s(gen_s:0':cons_g:cons_f2_2(c238_2))

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

(72)
BOUNDS(1, INF)